Cross Reference: /illumos-gate/usr/src/lib/libscf/common/lowlevel.c

Lines Matching refs:response
579  * returns NOT_BOUND.  If the door call fails or the server response is too
580  * small, returns CALL_FAILED.  If the server response is too big, truncates the
581  * response and returns RESULT_TOO_BIG.  Otherwise, the size of the result is
813  *		 server response too big
1006 	rep_protocol_response_t response;
1014 	    &response, sizeof (response));
1024  *   _INTERNAL - server response too big
1034 	rep_protocol_response_t response;
1052 	    &response, sizeof (response));
1059 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
1060 		return (scf_set_error(proto_error(response.rpr_response)));
1068  *   _INTERNAL - server response too big
1077 	struct rep_protocol_response response;
1092 	    &response, sizeof (response));
1099 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
1100 		return (scf_set_error(proto_error(response.rpr_response)));
1119  *		 server response too big
1134 	repository_door_response_t response;
1178 	    &response, sizeof (response), &handle->rh_doorfd);
1195 		switch (response.rdr_status) {
1514  *   _INTERNAL - server response too big
1567 	rep_protocol_response_t response;
1578 		    &response, sizeof (response));
1601 	rep_protocol_response_t response;
1609 	    &response, sizeof (response));
1641  * Fails with _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL (server response too
1652 	struct rep_protocol_name_response response;
1662 	    &response, sizeof (response));
1668 	if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
1669 		assert(response.rpr_response != REP_PROTOCOL_FAIL_BAD_REQUEST);
1670 		if (response.rpr_response == REP_PROTOCOL_FAIL_NOT_FOUND)
1672 		return (scf_set_error(proto_error(response.rpr_response)));
1674 	return (strlcpy(buf, response.rpr_name, size));
1679  * (server response too big, bad element id), _EXISTS (elements have same id),
1689 	struct rep_protocol_response response;
1704 	    &response, sizeof (response));
1710 	if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
1711 		if (response.rpr_response == REP_PROTOCOL_FAIL_TYPE_MISMATCH)
1713 		return (scf_set_error(proto_error(response.rpr_response)));
1721  * name is invalid), _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL (server response
1733 	struct rep_protocol_response response;
1769 	    &response, sizeof (response));
1774 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
1775 		return (scf_set_error(proto_error(response.rpr_response)));
1785 	    &response, sizeof (response));
1792 	if (response.rpr_response == REP_PROTOCOL_DONE) {
1796 	if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
1797 		if (response.rpr_response == REP_PROTOCOL_FAIL_NOT_SET ||
1798 		    response.rpr_response == REP_PROTOCOL_FAIL_BAD_REQUEST)
1800 		return (scf_set_error(proto_error(response.rpr_response)));
1808  * name is invalid), _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL (server response
1817 	struct rep_protocol_response response;
1843 	    &response, sizeof (response));
1848 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
1849 		return (scf_set_error(proto_error(response.rpr_response)));
1855  * name is invalid), _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL (server response
1938  *   _INTERNAL - server response too big
1960 	struct rep_protocol_response response;
2004 	    &response, sizeof (response));
2013 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
2014 		return (scf_set_error(proto_error(response.rpr_response)));
2031 	struct rep_protocol_response response;
2068 	    &response, sizeof (response));
2077 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
2078 		return (scf_set_error(proto_error(response.rpr_response)));
2094 	struct rep_protocol_response response;
2104 	    &response, sizeof (response));
2110 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
2111 		return (scf_set_error(proto_error(response.rpr_response)));
2121  *   _INTERNAL - server response too big
2177 	struct rep_protocol_response response;
2185 	    &request, sizeof (request), &response, sizeof (response));
2205 	struct rep_protocol_response response;
2217 	    &response, sizeof (response));
2232 	struct rep_protocol_name_response response;
2246 	    &response, sizeof (response));
2251 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
2252 		return (scf_set_error(proto_error(response.rpr_response)));
2344 	struct rep_protocol_response response;
2365 	    &response, sizeof (response));
2371 	if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
2373 		return (scf_set_error(proto_error(response.rpr_response)));
2387 	struct rep_protocol_response response;
2413 	    &response, sizeof (response));
2420 	if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
2422 		return (scf_set_error(proto_error(response.rpr_response)));
2435 	struct rep_protocol_response response;
2460 	    &response, sizeof (response));
2467 	if (response.rpr_response == REP_PROTOCOL_DONE) {
2471 	if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
2473 		return (scf_set_error(proto_error(response.rpr_response)));
2606  *   _INTERNAL - server response too big
2667  * (bad server response or id in use), _NO_RESOURCES, or _NO_MEMORY.
2894  * (bad server response or id in use), _NO_RESOURCES, or _NO_MEMORY.
2939  * (bad server response or id in use), _NO_RESOURCES, or _NO_MEMORY.
2984  * (bad server response or id in use), _NO_RESOURCES, _NO_MEMORY.
3063 	struct rep_protocol_response response;
3082 	    &response, sizeof (response));
3089 	    (response.rpr_response == REP_PROTOCOL_SUCCESS ||
3090 	    response.rpr_response == REP_PROTOCOL_DONE)) {
3104 	if (response.rpr_response != REP_PROTOCOL_SUCCESS &&
3105 	    response.rpr_response != REP_PROTOCOL_DONE) {
3106 		return (scf_set_error(proto_error(response.rpr_response)));
3109 	return (response.rpr_response == REP_PROTOCOL_SUCCESS) ?
3127  * (bad server response or id in use), _NO_RESOURCES, or _NO_MEMORY.
3199 	struct rep_protocol_response response;
3211 	    &response, sizeof (response));
3221 	if (response.rpr_response == REP_PROTOCOL_FAIL_BAD_REQUEST)
3224 	if (response.rpr_response != REP_PROTOCOL_SUCCESS &&
3225 	    response.rpr_response != REP_PROTOCOL_DONE) {
3226 		return (scf_set_error(proto_error(response.rpr_response)));
3229 	return (response.rpr_response == REP_PROTOCOL_SUCCESS) ?
3251 	struct rep_protocol_response response;
3267 	    &response, sizeof (response), &pollfd.fd);
3273 	assert((response.rpr_response == REP_PROTOCOL_SUCCESS) ==
3276 	if (response.rpr_response == REP_PROTOCOL_FAIL_NOT_LATEST)
3279 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
3280 		return (scf_set_error(proto_error(response.rpr_response)));
3295 	struct rep_protocol_response response;
3304 	    &response, sizeof (response));
3310 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
3311 		return (scf_set_error(proto_error(response.rpr_response)));
3332 	struct rep_protocol_fmri_response response;
3354 	    &response, sizeof (response), &dummy);
3376 	if (response.rpr_response == REP_PROTOCOL_DONE)
3379 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
3380 		return (scf_set_error(proto_error(response.rpr_response)));
3383 	return (strlcpy(out, response.rpr_fmri, sz));
3393 	struct rep_protocol_response response;
3414 	    &response, sizeof (response));
3420 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
3421 		return (scf_set_error(proto_error(response.rpr_response)));
3434 	struct rep_protocol_response response;
3462 	    &response, sizeof (response));
3468 	if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
3469 		assert(response.rpr_response !=
3471 		return (scf_set_error(proto_error(response.rpr_response)));
3496 	struct rep_protocol_response response;
3512 	    &response, sizeof (response));
3518 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
3519 		return (scf_set_error(proto_error(response.rpr_response)));
3526  * (bad server response or id in use), _NO_RESOURCES, or _NO_MEMORY.
3569 	struct rep_protocol_integer_response response;
3580 	    &response, sizeof (response));
3585 	if (response.rpr_response != REP_PROTOCOL_SUCCESS ||
3586 	    r < sizeof (response)) {
3587 		return (scf_set_error(proto_error(response.rpr_response)));
3589 	*out = response.rpr_value;
3660  * _INTERNAL (bad server response or id in use), or _NO_RESOURCES.
3701 	struct rep_protocol_response response;
3720 	    &response, sizeof (response));
3727 	/* r < sizeof (response) cannot happen because sizeof (response) == 4 */
3729 	if (response.rpr_response != REP_PROTOCOL_SUCCESS ||
3730 	    r < sizeof (response)) {
3732 		return (scf_set_error(proto_error(response.rpr_response)));
4042 	struct rep_protocol_response response;
4093 	    &response, sizeof (response));
4100 	if (response.rpr_response != REP_PROTOCOL_SUCCESS &&
4101 	    response.rpr_response != REP_PROTOCOL_FAIL_NOT_LATEST) {
4103 		return (scf_set_error(proto_error(response.rpr_response)));
4108 	return (response.rpr_response == REP_PROTOCOL_SUCCESS);
4996 	struct rep_protocol_value_response response;
5022 	    &response, sizeof (response));
5029 	if (response.rpr_response == REP_PROTOCOL_DONE) {
5033 	if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
5035 		return (scf_set_error(proto_error(response.rpr_response)));
5039 	v->value_type = response.rpr_type;
5041 	assert(scf_validate_encoded_value(response.rpr_type,
5042 	    response.rpr_value));
5045 		(void) strlcpy(v->value_value, response.rpr_value,
5049 		    response.rpr_value, sizeof (v->value_value));
5061 	struct rep_protocol_value_response response;
5076 	    &response, sizeof (response));
5083 	if (response.rpr_response != REP_PROTOCOL_SUCCESS &&
5084 	    response.rpr_response != REP_PROTOCOL_FAIL_TRUNCATED) {
5086 		assert(response.rpr_response !=
5088 		return (scf_set_error(proto_error(response.rpr_response)));
5091 	v->value_type = response.rpr_type;
5093 		(void) strlcpy(v->value_value, response.rpr_value,
5097 		    response.rpr_value, sizeof (v->value_value));
5100 	return ((response.rpr_response == REP_PROTOCOL_SUCCESS)?
5672  * Fails with _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL (server response too
5704  * Fails with _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL (server response too
5796 	struct rep_protocol_integer_response response;
5807 	    &response, sizeof (response));
5813 	if (response.rpr_response != REP_PROTOCOL_SUCCESS ||
5814 	    r < sizeof (response)) {
5815 		return (scf_set_error(proto_error(response.rpr_response)));
5818 	switch (response.rpr_value) {
5934  * (server response too big, bad entity id, request not applicable to entity,
6264  * response or id in use), _NO_MEMORY, _HANDLE_MISMATCH, _CONSTRAINT_VIOLATED,
7319 	struct rep_protocol_response response;
7332 	    &response, sizeof (response));
7339 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
7340 		return (scf_set_error(proto_error(response.rpr_response)));
7352  *				the server response is too big
7362 	struct rep_protocol_response response;
7376 	    &response, sizeof (response));
7387 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
7388 		return (scf_set_error(proto_error(response.rpr_response)));
7425 	struct rep_protocol_response response;
7449 	    &response, sizeof (response));
7456 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
7457 		return (scf_set_error(proto_error(response.rpr_response)));