Lines Matching defs:response
677 * returns NOT_BOUND. If the door call fails or the server response is too
678 * small, returns CALL_FAILED. If the server response is too big, truncates the
679 * response and returns RESULT_TOO_BIG. Otherwise, the size of the result is
913 * server response too big
1060 rep_protocol_response_t response;
1068 &response, sizeof (response));
1078 * _INTERNAL - server response too big
1088 rep_protocol_response_t response;
1106 &response, sizeof (response));
1113 if (response.rpr_response != REP_PROTOCOL_SUCCESS)
1114 return (scf_set_error(proto_error(response.rpr_response)));
1122 * _INTERNAL - server response too big
1131 struct rep_protocol_response response;
1146 &response, sizeof (response));
1153 if (response.rpr_response != REP_PROTOCOL_SUCCESS)
1154 return (scf_set_error(proto_error(response.rpr_response)));
1173 * server response too big
1188 repository_door_response_t response;
1232 &response, sizeof (response), &handle->rh_doorfd);
1249 switch (response.rdr_status) {
1568 * _INTERNAL - server response too big
1621 rep_protocol_response_t response;
1632 &response, sizeof (response));
1655 rep_protocol_response_t response;
1663 &response, sizeof (response));
1695 * Fails with _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL (server response too
1706 struct rep_protocol_name_response response;
1716 &response, sizeof (response));
1722 if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
1723 assert(response.rpr_response != REP_PROTOCOL_FAIL_BAD_REQUEST);
1724 if (response.rpr_response == REP_PROTOCOL_FAIL_NOT_FOUND)
1726 return (scf_set_error(proto_error(response.rpr_response)));
1728 return (strlcpy(buf, response.rpr_name, size));
1733 * (server response too big, bad element id), _EXISTS (elements have same id),
1743 struct rep_protocol_response response;
1758 &response, sizeof (response));
1764 if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
1765 if (response.rpr_response == REP_PROTOCOL_FAIL_TYPE_MISMATCH)
1767 return (scf_set_error(proto_error(response.rpr_response)));
1775 * name is invalid), _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL (server response
1787 struct rep_protocol_response response;
1823 &response, sizeof (response));
1828 if (response.rpr_response != REP_PROTOCOL_SUCCESS)
1829 return (scf_set_error(proto_error(response.rpr_response)));
1839 &response, sizeof (response));
1846 if (response.rpr_response == REP_PROTOCOL_DONE) {
1850 if (response.rpr_response == REP_PROTOCOL_FAIL_TRUNCATED)
1853 if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
1854 if (response.rpr_response == REP_PROTOCOL_FAIL_NOT_SET ||
1855 response.rpr_response == REP_PROTOCOL_FAIL_BAD_REQUEST)
1857 return (scf_set_error(proto_error(response.rpr_response)));
1865 * name is invalid), _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL (server response
1874 struct rep_protocol_response response;
1900 &response, sizeof (response));
1905 if (response.rpr_response == REP_PROTOCOL_FAIL_TRUNCATED)
1908 if (response.rpr_response != REP_PROTOCOL_SUCCESS)
1909 return (scf_set_error(proto_error(response.rpr_response)));
1915 * name is invalid), _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL (server response
1995 struct rep_protocol_response response;
2005 &response, sizeof (response));
2011 if (response.rpr_response != REP_PROTOCOL_SUCCESS)
2012 return (scf_set_error(proto_error(response.rpr_response)));
2036 struct rep_protocol_integer_response response;
2045 r = make_door_call(h, &request, sizeof (request), &response,
2046 sizeof (response));
2051 if ((response.rpr_response != REP_PROTOCOL_SUCCESS) ||
2052 (r < sizeof (response))) {
2053 return (scf_set_error(proto_error(response.rpr_response)));
2056 return (response.rpr_value);
2068 * _INTERNAL - server response too big
2090 struct rep_protocol_response response;
2134 &response, sizeof (response));
2143 if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
2148 if (response.rpr_response == REP_PROTOCOL_FAIL_EXISTS) {
2157 return (scf_set_error(proto_error(response.rpr_response)));
2175 struct rep_protocol_response response;
2212 &response, sizeof (response));
2221 if (response.rpr_response != REP_PROTOCOL_SUCCESS)
2222 return (scf_set_error(proto_error(response.rpr_response)));
2238 struct rep_protocol_response response;
2248 &response, sizeof (response));
2254 if (response.rpr_response != REP_PROTOCOL_SUCCESS)
2255 return (scf_set_error(proto_error(response.rpr_response)));
2266 struct rep_protocol_response response;
2276 &response, sizeof (response));
2282 if (response.rpr_response != REP_PROTOCOL_SUCCESS)
2283 return (scf_set_error(proto_error(response.rpr_response)));
2294 struct rep_protocol_response response;
2304 &response, sizeof (response));
2310 if (response.rpr_response != REP_PROTOCOL_SUCCESS)
2311 return (scf_set_error(proto_error(response.rpr_response)));
2331 struct rep_protocol_response response;
2361 &response, sizeof (response));
2367 if (response.rpr_response != REP_PROTOCOL_SUCCESS)
2368 return (scf_set_error(proto_error(response.rpr_response)));
2379 struct rep_protocol_integer_response response;
2385 response.rpr_value = 0;
2389 &response, sizeof (response));
2395 if (response.rpr_response != REP_PROTOCOL_SUCCESS)
2396 return (scf_set_error(proto_error(response.rpr_response)));
2398 return (response.rpr_value);
2406 * _INTERNAL - server response too big
2462 struct rep_protocol_response response;
2470 &request, sizeof (request), &response, sizeof (response));
2490 struct rep_protocol_response response;
2502 &response, sizeof (response));
2517 struct rep_protocol_name_response response;
2531 &response, sizeof (response));
2536 if (response.rpr_response != REP_PROTOCOL_SUCCESS)
2537 return (scf_set_error(proto_error(response.rpr_response)));
2631 struct rep_protocol_response response;
2653 &response, sizeof (response));
2659 if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
2661 return (scf_set_error(proto_error(response.rpr_response)));
2675 struct rep_protocol_response response;
2701 &response, sizeof (response));
2708 if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
2710 return (scf_set_error(proto_error(response.rpr_response)));
2723 struct rep_protocol_response response;
2748 &response, sizeof (response));
2755 if (response.rpr_response == REP_PROTOCOL_DONE) {
2760 if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
2762 return (scf_set_error(proto_error(response.rpr_response)));
2936 * _INTERNAL - server response too big
2997 * (bad server response or id in use), _NO_RESOURCES, or _NO_MEMORY.
3314 struct rep_protocol_response response;
3334 &response, sizeof (response));
3342 if (response.rpr_response != REP_PROTOCOL_SUCCESS &&
3343 response.rpr_response != REP_PROTOCOL_FAIL_NOT_LATEST) {
3345 return (scf_set_error(proto_error(response.rpr_response)));
3350 return (response.rpr_response == REP_PROTOCOL_SUCCESS);
3541 * (bad server response or id in use), _NO_RESOURCES, or _NO_MEMORY.
3586 * (bad server response or id in use), _NO_RESOURCES, or _NO_MEMORY.
3631 * (bad server response or id in use), _NO_RESOURCES, _NO_MEMORY.
3710 struct rep_protocol_response response;
3729 &response, sizeof (response));
3736 (response.rpr_response == REP_PROTOCOL_SUCCESS ||
3737 response.rpr_response == REP_PROTOCOL_DONE)) {
3751 if (response.rpr_response != REP_PROTOCOL_SUCCESS &&
3752 response.rpr_response != REP_PROTOCOL_DONE) {
3753 return (scf_set_error(proto_error(response.rpr_response)));
3756 return (response.rpr_response == REP_PROTOCOL_SUCCESS) ?
3774 * (bad server response or id in use), _NO_RESOURCES, or _NO_MEMORY.
3846 struct rep_protocol_response response;
3858 &response, sizeof (response));
3868 if (response.rpr_response == REP_PROTOCOL_FAIL_BAD_REQUEST)
3871 if (response.rpr_response != REP_PROTOCOL_SUCCESS &&
3872 response.rpr_response != REP_PROTOCOL_DONE) {
3873 return (scf_set_error(proto_error(response.rpr_response)));
3876 return (response.rpr_response == REP_PROTOCOL_SUCCESS) ?
3898 struct rep_protocol_response response;
3914 &response, sizeof (response), &pollfd.fd);
3920 assert((response.rpr_response == REP_PROTOCOL_SUCCESS) ==
3923 if (response.rpr_response == REP_PROTOCOL_FAIL_NOT_LATEST)
3926 if (response.rpr_response != REP_PROTOCOL_SUCCESS)
3927 return (scf_set_error(proto_error(response.rpr_response)));
3942 struct rep_protocol_response response;
3951 &response, sizeof (response));
3957 if (response.rpr_response != REP_PROTOCOL_SUCCESS)
3958 return (scf_set_error(proto_error(response.rpr_response)));
3979 struct rep_protocol_fmri_response response;
4001 &response, sizeof (response), &dummy);
4023 if (response.rpr_response == REP_PROTOCOL_DONE)
4026 if (response.rpr_response != REP_PROTOCOL_SUCCESS)
4027 return (scf_set_error(proto_error(response.rpr_response)));
4030 return (strlcpy(out, response.rpr_fmri, sz));
4040 struct rep_protocol_response response;
4061 &response, sizeof (response));
4067 if (response.rpr_response != REP_PROTOCOL_SUCCESS)
4068 return (scf_set_error(proto_error(response.rpr_response)));
4081 struct rep_protocol_response response;
4109 &response, sizeof (response));
4115 if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
4116 assert(response.rpr_response !=
4118 return (scf_set_error(proto_error(response.rpr_response)));
4143 struct rep_protocol_response response;
4159 &response, sizeof (response));
4165 if (response.rpr_response != REP_PROTOCOL_SUCCESS)
4166 return (scf_set_error(proto_error(response.rpr_response)));
4173 * (bad server response or id in use), _NO_RESOURCES, or _NO_MEMORY.
4216 struct rep_protocol_integer_response response;
4227 &response, sizeof (response));
4232 if (response.rpr_response != REP_PROTOCOL_SUCCESS ||
4233 r < sizeof (response)) {
4234 return (scf_set_error(proto_error(response.rpr_response)));
4236 *out = response.rpr_value;
4286 struct rep_protocol_integer_response response;
4297 &response, sizeof (response));
4302 if (response.rpr_response != REP_PROTOCOL_SUCCESS ||
4303 r < sizeof (response)) {
4304 return (scf_set_error(proto_error(response.rpr_response)));
4306 *out = response.rpr_value;
4420 struct rep_protocol_integer_response response;
4431 &response, sizeof (response));
4436 if (response.rpr_response != REP_PROTOCOL_SUCCESS ||
4437 r < sizeof (response)) {
4438 return (scf_set_error(proto_error(response.rpr_response)));
4440 *out = response.rpr_value;
4452 struct rep_protocol_path_response response;
4461 r = make_door_call(h, &request, sizeof (request), & response,
4462 sizeof (response));
4468 if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
4469 assert(response.rpr_response != REP_PROTOCOL_FAIL_BAD_REQUEST);
4470 return (scf_set_error(proto_error(response.rpr_response)));
4473 return (strlcpy(out, response.rpr_path, len));
4503 * _INTERNAL (bad server response or id in use), or _NO_RESOURCES.
4544 struct rep_protocol_response response;
4563 &response, sizeof (response));
4570 /* r < sizeof (response) cannot happen because sizeof (response) == 4 */
4572 if (response.rpr_response != REP_PROTOCOL_SUCCESS ||
4573 r < sizeof (response)) {
4575 return (scf_set_error(proto_error(response.rpr_response)));
4917 struct rep_protocol_response response;
4931 &response, sizeof (response));
4939 if (response.rpr_response != REP_PROTOCOL_SUCCESS &&
4940 response.rpr_response != REP_PROTOCOL_FAIL_NOT_LATEST) {
4942 return (scf_set_error(proto_error(response.rpr_response)));
4947 return (response.rpr_response == REP_PROTOCOL_SUCCESS);
5890 struct rep_protocol_value_response response;
5916 &response, sizeof (response));
5923 if (response.rpr_response == REP_PROTOCOL_DONE) {
5927 if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
5929 return (scf_set_error(proto_error(response.rpr_response)));
5933 v->value_type = response.rpr_type;
5935 assert(scf_validate_encoded_value(response.rpr_type,
5936 response.rpr_value));
5939 (void) strlcpy(v->value_value, response.rpr_value,
5943 response.rpr_value, sizeof (v->value_value));
5966 struct rep_protocol_value_response response;
5981 &response, sizeof (response));
5988 if (response.rpr_response != REP_PROTOCOL_SUCCESS &&
5989 response.rpr_response != REP_PROTOCOL_FAIL_TRUNCATED) {
5991 assert(response.rpr_response !=
5993 return (scf_set_error(proto_error(response.rpr_response)));
5996 v->value_type = response.rpr_type;
5998 (void) strlcpy(v->value_value, response.rpr_value,
6002 response.rpr_value, sizeof (v->value_value));
6005 return ((response.rpr_response == REP_PROTOCOL_SUCCESS)?
6034 struct rep_protocol_value_response response;
6049 &response, sizeof (response));
6056 if (response.rpr_response != REP_PROTOCOL_SUCCESS &&
6057 response.rpr_response != REP_PROTOCOL_FAIL_TRUNCATED) {
6059 assert(response.rpr_response !=
6061 return (scf_set_error(proto_error(response.rpr_response)));
6064 v->value_type = response.rpr_type;
6066 (void) strlcpy(v->value_value, response.rpr_value,
6070 response.rpr_value, sizeof (v->value_value));
6074 return ((response.rpr_response == REP_PROTOCOL_SUCCESS) ?
6646 * Fails with _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL (server response too
6678 * Fails with _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL (server response too
6770 struct rep_protocol_integer_response response;
6781 &response, sizeof (response));
6787 if (response.rpr_response != REP_PROTOCOL_SUCCESS ||
6788 r < sizeof (response)) {
6789 return (scf_set_error(proto_error(response.rpr_response)));
6792 switch (response.rpr_value) {
6908 * (server response too big, bad entity id, request not applicable to entity,
7238 * response or id in use), _NO_MEMORY, _HANDLE_MISMATCH, _CONSTRAINT_VIOLATED,
8275 struct rep_protocol_response response;
8288 &response, sizeof (response));
8295 if (response.rpr_response != REP_PROTOCOL_SUCCESS)
8296 return (scf_set_error(proto_error(response.rpr_response)));
8308 * the server response is too big
8318 struct rep_protocol_response response;
8332 &response, sizeof (response));
8343 if (response.rpr_response != REP_PROTOCOL_SUCCESS)
8344 return (scf_set_error(proto_error(response.rpr_response)));
8381 struct rep_protocol_response response;
8391 &response, sizeof (response));
8398 if (response.rpr_response != REP_PROTOCOL_SUCCESS)
8399 return (scf_set_error(proto_error(response.rpr_response)));
8407 struct rep_protocol_response response;
8417 &response, sizeof (response));
8424 if (response.rpr_response != REP_PROTOCOL_SUCCESS)
8425 return (scf_set_error(proto_error(response.rpr_response)));
8434 struct rep_protocol_response response;
8451 &response, sizeof (response));
8458 if (response.rpr_response != REP_PROTOCOL_SUCCESS)
8459 return (scf_set_error(proto_error(response.rpr_response)));