}
if (!err) {
- err = k5_ipc_stream_read_uint32 (io_stream, &v4creds->version);
+ err = krb5int_ipc_stream_read_uint32 (io_stream, &v4creds->version);
}
if (!err) {
- err = k5_ipc_stream_read (io_stream, v4creds->principal, cc_v4_name_size);
+ err = krb5int_ipc_stream_read (io_stream, v4creds->principal, cc_v4_name_size);
}
if (!err) {
- err = k5_ipc_stream_read (io_stream, v4creds->principal_instance, cc_v4_instance_size);
+ err = krb5int_ipc_stream_read (io_stream, v4creds->principal_instance, cc_v4_instance_size);
}
if (!err) {
- err = k5_ipc_stream_read (io_stream, v4creds->service, cc_v4_name_size);
+ err = krb5int_ipc_stream_read (io_stream, v4creds->service, cc_v4_name_size);
}
if (!err) {
- err = k5_ipc_stream_read (io_stream, v4creds->service_instance, cc_v4_instance_size);
+ err = krb5int_ipc_stream_read (io_stream, v4creds->service_instance, cc_v4_instance_size);
}
if (!err) {
- err = k5_ipc_stream_read (io_stream, v4creds->realm, cc_v4_realm_size);
+ err = krb5int_ipc_stream_read (io_stream, v4creds->realm, cc_v4_realm_size);
}
if (!err) {
- err = k5_ipc_stream_read (io_stream, v4creds->session_key, cc_v4_key_size);
+ err = krb5int_ipc_stream_read (io_stream, v4creds->session_key, cc_v4_key_size);
}
if (!err) {
- err = k5_ipc_stream_read_int32 (io_stream, &v4creds->kvno);
+ err = krb5int_ipc_stream_read_int32 (io_stream, &v4creds->kvno);
}
if (!err) {
- err = k5_ipc_stream_read_int32 (io_stream, &v4creds->string_to_key_type);
+ err = krb5int_ipc_stream_read_int32 (io_stream, &v4creds->string_to_key_type);
}
if (!err) {
- err = k5_ipc_stream_read_time (io_stream, &v4creds->issue_date);
+ err = krb5int_ipc_stream_read_time (io_stream, &v4creds->issue_date);
}
if (!err) {
- err = k5_ipc_stream_read_int32 (io_stream, &v4creds->lifetime);
+ err = krb5int_ipc_stream_read_int32 (io_stream, &v4creds->lifetime);
}
if (!err) {
- err = k5_ipc_stream_read_uint32 (io_stream, &v4creds->address);
+ err = krb5int_ipc_stream_read_uint32 (io_stream, &v4creds->address);
}
if (!err) {
- err = k5_ipc_stream_read_int32 (io_stream, &v4creds->ticket_size);
+ err = krb5int_ipc_stream_read_int32 (io_stream, &v4creds->ticket_size);
}
if (!err) {
- err = k5_ipc_stream_read (io_stream, v4creds->ticket, cc_v4_ticket_size);
+ err = krb5int_ipc_stream_read (io_stream, v4creds->ticket, cc_v4_ticket_size);
}
if (!err) {
if (!in_v4creds) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_write_uint32 (io_stream, in_v4creds->version);
+ err = krb5int_ipc_stream_write_uint32 (io_stream, in_v4creds->version);
}
if (!err) {
- err = k5_ipc_stream_write (io_stream, in_v4creds->principal, cc_v4_name_size);
+ err = krb5int_ipc_stream_write (io_stream, in_v4creds->principal, cc_v4_name_size);
}
if (!err) {
- err = k5_ipc_stream_write (io_stream, in_v4creds->principal_instance, cc_v4_instance_size);
+ err = krb5int_ipc_stream_write (io_stream, in_v4creds->principal_instance, cc_v4_instance_size);
}
if (!err) {
- err = k5_ipc_stream_write (io_stream, in_v4creds->service, cc_v4_name_size);
+ err = krb5int_ipc_stream_write (io_stream, in_v4creds->service, cc_v4_name_size);
}
if (!err) {
- err = k5_ipc_stream_write (io_stream, in_v4creds->service_instance, cc_v4_instance_size);
+ err = krb5int_ipc_stream_write (io_stream, in_v4creds->service_instance, cc_v4_instance_size);
}
if (!err) {
- err = k5_ipc_stream_write (io_stream, in_v4creds->realm, cc_v4_realm_size);
+ err = krb5int_ipc_stream_write (io_stream, in_v4creds->realm, cc_v4_realm_size);
}
if (!err) {
- err = k5_ipc_stream_write (io_stream, in_v4creds->session_key, cc_v4_key_size);
+ err = krb5int_ipc_stream_write (io_stream, in_v4creds->session_key, cc_v4_key_size);
}
if (!err) {
- err = k5_ipc_stream_write_int32 (io_stream, in_v4creds->kvno);
+ err = krb5int_ipc_stream_write_int32 (io_stream, in_v4creds->kvno);
}
if (!err) {
- err = k5_ipc_stream_write_int32 (io_stream, in_v4creds->string_to_key_type);
+ err = krb5int_ipc_stream_write_int32 (io_stream, in_v4creds->string_to_key_type);
}
if (!err) {
- err = k5_ipc_stream_write_time (io_stream, in_v4creds->issue_date);
+ err = krb5int_ipc_stream_write_time (io_stream, in_v4creds->issue_date);
}
if (!err) {
- err = k5_ipc_stream_write_int32 (io_stream, in_v4creds->lifetime);
+ err = krb5int_ipc_stream_write_int32 (io_stream, in_v4creds->lifetime);
}
if (!err) {
- err = k5_ipc_stream_write_uint32 (io_stream, in_v4creds->address);
+ err = krb5int_ipc_stream_write_uint32 (io_stream, in_v4creds->address);
}
if (!err) {
- err = k5_ipc_stream_write_int32 (io_stream, in_v4creds->ticket_size);
+ err = krb5int_ipc_stream_write_int32 (io_stream, in_v4creds->ticket_size);
}
if (!err) {
- err = k5_ipc_stream_write (io_stream, in_v4creds->ticket, cc_v4_ticket_size);
+ err = krb5int_ipc_stream_write (io_stream, in_v4creds->ticket, cc_v4_ticket_size);
}
return cci_check_error (err);
if (!io_ccdata) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_read_uint32 (io_stream, &type);
+ err = krb5int_ipc_stream_read_uint32 (io_stream, &type);
}
if (!err) {
- err = k5_ipc_stream_read_uint32 (io_stream, &length);
+ err = krb5int_ipc_stream_read_uint32 (io_stream, &length);
}
if (!err && length > 0) {
if (!data) { err = cci_check_error (ccErrNoMem); }
if (!err) {
- err = k5_ipc_stream_read (io_stream, data, length);
+ err = krb5int_ipc_stream_read (io_stream, data, length);
}
}
if (!in_ccdata) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_write_uint32 (io_stream, in_ccdata->type);
+ err = krb5int_ipc_stream_write_uint32 (io_stream, in_ccdata->type);
}
if (!err) {
- err = k5_ipc_stream_write_uint32 (io_stream, in_ccdata->length);
+ err = krb5int_ipc_stream_write_uint32 (io_stream, in_ccdata->length);
}
if (!err && in_ccdata->length > 0) {
- err = k5_ipc_stream_write (io_stream, in_ccdata->data, in_ccdata->length);
+ err = krb5int_ipc_stream_write (io_stream, in_ccdata->data, in_ccdata->length);
}
return cci_check_error (err);
if (!io_ccdata_array) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_read_uint32 (io_stream, &count);
+ err = krb5int_ipc_stream_read_uint32 (io_stream, &count);
}
if (!err && count > 0) {
if (!err) {
for (count = 0; in_ccdata_array && in_ccdata_array[count]; count++);
- err = k5_ipc_stream_write_uint32 (io_stream, count);
+ err = krb5int_ipc_stream_write_uint32 (io_stream, count);
}
if (!err) {
}
if (!err) {
- err = k5_ipc_stream_read_string (io_stream, &v5creds->client);
+ err = krb5int_ipc_stream_read_string (io_stream, &v5creds->client);
}
if (!err) {
- err = k5_ipc_stream_read_string (io_stream, &v5creds->server);
+ err = krb5int_ipc_stream_read_string (io_stream, &v5creds->server);
}
if (!err) {
}
if (!err) {
- err = k5_ipc_stream_read_time (io_stream, &v5creds->authtime);
+ err = krb5int_ipc_stream_read_time (io_stream, &v5creds->authtime);
}
if (!err) {
- err = k5_ipc_stream_read_time (io_stream, &v5creds->starttime);
+ err = krb5int_ipc_stream_read_time (io_stream, &v5creds->starttime);
}
if (!err) {
- err = k5_ipc_stream_read_time (io_stream, &v5creds->endtime);
+ err = krb5int_ipc_stream_read_time (io_stream, &v5creds->endtime);
}
if (!err) {
- err = k5_ipc_stream_read_time (io_stream, &v5creds->renew_till);
+ err = krb5int_ipc_stream_read_time (io_stream, &v5creds->renew_till);
}
if (!err) {
- err = k5_ipc_stream_read_uint32 (io_stream, &v5creds->is_skey);
+ err = krb5int_ipc_stream_read_uint32 (io_stream, &v5creds->is_skey);
}
if (!err) {
- err = k5_ipc_stream_read_uint32 (io_stream, &v5creds->ticket_flags);
+ err = krb5int_ipc_stream_read_uint32 (io_stream, &v5creds->ticket_flags);
}
if (!err) {
if (!in_v5creds) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_write_string (io_stream, in_v5creds->client);
+ err = krb5int_ipc_stream_write_string (io_stream, in_v5creds->client);
}
if (!err) {
- err = k5_ipc_stream_write_string (io_stream, in_v5creds->server);
+ err = krb5int_ipc_stream_write_string (io_stream, in_v5creds->server);
}
if (!err) {
}
if (!err) {
- err = k5_ipc_stream_write_time (io_stream, in_v5creds->authtime);
+ err = krb5int_ipc_stream_write_time (io_stream, in_v5creds->authtime);
}
if (!err) {
- err = k5_ipc_stream_write_time (io_stream, in_v5creds->starttime);
+ err = krb5int_ipc_stream_write_time (io_stream, in_v5creds->starttime);
}
if (!err) {
- err = k5_ipc_stream_write_time (io_stream, in_v5creds->endtime);
+ err = krb5int_ipc_stream_write_time (io_stream, in_v5creds->endtime);
}
if (!err) {
- err = k5_ipc_stream_write_time (io_stream, in_v5creds->renew_till);
+ err = krb5int_ipc_stream_write_time (io_stream, in_v5creds->renew_till);
}
if (!err) {
- err = k5_ipc_stream_write_uint32 (io_stream, in_v5creds->is_skey);
+ err = krb5int_ipc_stream_write_uint32 (io_stream, in_v5creds->is_skey);
}
if (!err) {
- err = k5_ipc_stream_write_uint32 (io_stream, in_v5creds->ticket_flags);
+ err = krb5int_ipc_stream_write_uint32 (io_stream, in_v5creds->ticket_flags);
}
if (!err) {
}
if (!err) {
- err = k5_ipc_stream_read_uint32 (io_stream, &credentials_union->version);
+ err = krb5int_ipc_stream_read_uint32 (io_stream, &credentials_union->version);
}
if (!err) {
if (!in_credentials_union) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_write_uint32 (io_stream, in_credentials_union->version);
+ err = krb5int_ipc_stream_write_uint32 (io_stream, in_credentials_union->version);
}
if (!err) {
if (!io_stream ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_read_string (io_stream, &server_id);
+ err = krb5int_ipc_stream_read_string (io_stream, &server_id);
}
if (!err) {
- err = k5_ipc_stream_read_string (io_stream, &object_id);
+ err = krb5int_ipc_stream_read_string (io_stream, &object_id);
}
if (!err) {
err = cci_identifier_alloc (out_identifier, server_id, object_id);
}
- k5_ipc_stream_free_string (server_id);
- k5_ipc_stream_free_string (object_id);
+ krb5int_ipc_stream_free_string (server_id);
+ krb5int_ipc_stream_free_string (object_id);
return cci_check_error (err);
}
if (!io_stream ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_write_string (io_stream, in_identifier->server_id);
+ err = krb5int_ipc_stream_write_string (io_stream, in_identifier->server_id);
}
if (!err) {
- err = k5_ipc_stream_write_string (io_stream, in_identifier->object_id);
+ err = krb5int_ipc_stream_write_string (io_stream, in_identifier->object_id);
}
return cci_check_error (err);
if (!out_request) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_new (&request);
+ err = krb5int_ipc_stream_new (&request);
}
if (!err) {
- err = k5_ipc_stream_write_uint32 (request, in_request_name);
+ err = krb5int_ipc_stream_write_uint32 (request, in_request_name);
}
if (!err) {
request = NULL;
}
- k5_ipc_stream_release (request);
+ krb5int_ipc_stream_release (request);
return cci_check_error (err);
}
if (!out_identifier ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_read_uint32 (in_request, &request_name);
+ err = krb5int_ipc_stream_read_uint32 (in_request, &request_name);
}
if (!err) {
if (!out_reply) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_new (&reply);
+ err = krb5int_ipc_stream_new (&reply);
}
if (!err) {
- err = k5_ipc_stream_write_int32 (reply, in_error);
+ err = krb5int_ipc_stream_write_int32 (reply, in_error);
}
if (!err) {
reply = NULL;
}
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (reply);
return cci_check_error (err);
}
if (!out_reply_error) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_read_int32 (in_reply, &reply_err);
+ err = krb5int_ipc_stream_read_int32 (in_reply, &reply_err);
}
if (!err) {
/* ------------------------------------------------------------------------ */
-uint32_t k5_ipc_stream_read_time (k5_ipc_stream io_stream,
+uint32_t krb5int_ipc_stream_read_time (k5_ipc_stream io_stream,
cc_time_t *out_time)
{
int32_t err = 0;
if (!out_time ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_read_int64 (io_stream, &t);
+ err = krb5int_ipc_stream_read_int64 (io_stream, &t);
}
if (!err) {
/* ------------------------------------------------------------------------ */
-uint32_t k5_ipc_stream_write_time (k5_ipc_stream io_stream,
- cc_time_t in_time)
+uint32_t krb5int_ipc_stream_write_time (k5_ipc_stream io_stream,
+ cc_time_t in_time)
{
int32_t err = 0;
if (!io_stream) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_write_int64 (io_stream, in_time);
+ err = krb5int_ipc_stream_write_int64 (io_stream, in_time);
}
return cci_check_error (err);
cc_int32 cci_message_read_reply_header (k5_ipc_stream in_reply,
cc_int32 *out_reply_error);
-uint32_t k5_ipc_stream_read_time (k5_ipc_stream io_stream,
- cc_time_t *out_time);
-uint32_t k5_ipc_stream_write_time (k5_ipc_stream io_stream,
- cc_time_t in_time);
+uint32_t krb5int_ipc_stream_read_time (k5_ipc_stream io_stream,
+ cc_time_t *out_time);
+uint32_t krb5int_ipc_stream_write_time (k5_ipc_stream io_stream,
+ cc_time_t in_time);
#endif /* CCI_MESSAGE_H */
}
if (!err) {
- err = k5_ipc_stream_read_uint32 (reply, out_credentials_version);
+ err = krb5int_ipc_stream_read_uint32 (reply, out_credentials_version);
}
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (reply);
return cci_check_error (err);
}
}
if (!err) {
- err = k5_ipc_stream_read_string (reply, &name);
+ err = krb5int_ipc_stream_read_string (reply, &name);
}
if (!err) {
err = cci_string_new (out_name, name);
}
- k5_ipc_stream_release (reply);
- k5_ipc_stream_free_string (name);
+ krb5int_ipc_stream_release (reply);
+ krb5int_ipc_stream_free_string (name);
return cci_check_error (err);
}
if (!out_principal) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_new (&request);
+ err = krb5int_ipc_stream_new (&request);
}
if (!err) {
- err = k5_ipc_stream_write_uint32 (request, in_credentials_version);
+ err = krb5int_ipc_stream_write_uint32 (request, in_credentials_version);
}
if (!err) {
}
if (!err) {
- err = k5_ipc_stream_read_string (reply, &principal);
+ err = krb5int_ipc_stream_read_string (reply, &principal);
}
if (!err) {
err = cci_string_new (out_principal, principal);
}
- k5_ipc_stream_release (request);
- k5_ipc_stream_release (reply);
- k5_ipc_stream_free_string (principal);
+ krb5int_ipc_stream_release (request);
+ krb5int_ipc_stream_release (reply);
+ krb5int_ipc_stream_free_string (principal);
return cci_check_error (err);
}
if (!in_principal) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_new (&request);
+ err = krb5int_ipc_stream_new (&request);
}
if (!err) {
- err = k5_ipc_stream_write_uint32 (request, in_credentials_version);
+ err = krb5int_ipc_stream_write_uint32 (request, in_credentials_version);
}
if (!err) {
- err = k5_ipc_stream_write_string (request, in_principal);
+ err = krb5int_ipc_stream_write_string (request, in_principal);
}
if (!err) {
NULL);
}
- k5_ipc_stream_release (request);
+ krb5int_ipc_stream_release (request);
return cci_check_error (err);
}
if (!in_credentials_union) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_new (&request);
+ err = krb5int_ipc_stream_new (&request);
}
if (!err) {
NULL);
}
- k5_ipc_stream_release (request);
+ krb5int_ipc_stream_release (request);
return cci_check_error (err);
}
if (!in_credentials) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_new (&request);
+ err = krb5int_ipc_stream_new (&request);
}
if (!err) {
NULL);
}
- k5_ipc_stream_release (request);
+ krb5int_ipc_stream_release (request);
return cci_check_error (err);
}
err = cci_credentials_iterator_new (out_credentials_iterator, identifier);
}
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (reply);
cci_identifier_release (identifier);
return cci_check_error (err);
if (!io_destination_ccache) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_new (&request);
+ err = krb5int_ipc_stream_new (&request);
}
if (!err) {
NULL);
}
- k5_ipc_stream_release (request);
+ krb5int_ipc_stream_release (request);
return cci_check_error (err);
}
if (!io_ccache) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_new (&request);
+ err = krb5int_ipc_stream_new (&request);
}
if (!err) {
- err = k5_ipc_stream_write_uint32 (request, in_lock_type);
+ err = krb5int_ipc_stream_write_uint32 (request, in_lock_type);
}
if (!err) {
- err = k5_ipc_stream_write_uint32 (request, in_block);
+ err = krb5int_ipc_stream_write_uint32 (request, in_block);
}
if (!err) {
NULL);
}
- k5_ipc_stream_release (request);
+ krb5int_ipc_stream_release (request);
return cci_check_error (err);
}
}
if (!err) {
- err = k5_ipc_stream_read_time (reply, out_last_default_time);
+ err = krb5int_ipc_stream_read_time (reply, out_last_default_time);
}
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (reply);
return cci_check_error (err);
}
}
if (!err) {
- err = k5_ipc_stream_read_time (reply, out_change_time);
+ err = krb5int_ipc_stream_read_time (reply, out_change_time);
}
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (reply);
return cci_check_error (err);
}
if (!in_ccache) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_new (&request);
+ err = krb5int_ipc_stream_new (&request);
}
if (!err) {
- err = k5_ipc_stream_write_time (request, ccache->last_wait_for_change_time);
+ err = krb5int_ipc_stream_write_time (request, ccache->last_wait_for_change_time);
}
if (!err) {
}
if (!err) {
- err = k5_ipc_stream_read_time (reply, &ccache->last_wait_for_change_time);
+ err = krb5int_ipc_stream_read_time (reply, &ccache->last_wait_for_change_time);
}
- k5_ipc_stream_release (request);
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (request);
+ krb5int_ipc_stream_release (reply);
return cci_check_error (err);
}
if (!out_time_offset) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_new (&request);
+ err = krb5int_ipc_stream_new (&request);
}
if (!err) {
- err = k5_ipc_stream_write_uint32 (request, in_credentials_version);
+ err = krb5int_ipc_stream_write_uint32 (request, in_credentials_version);
}
if (!err) {
}
if (!err) {
- err = k5_ipc_stream_read_time (reply, out_time_offset);
+ err = krb5int_ipc_stream_read_time (reply, out_time_offset);
}
- k5_ipc_stream_release (request);
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (request);
+ krb5int_ipc_stream_release (reply);
return cci_check_error (err);
}
if (!io_ccache) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_new (&request);
+ err = krb5int_ipc_stream_new (&request);
}
if (!err) {
- err = k5_ipc_stream_write_uint32 (request, in_credentials_version);
+ err = krb5int_ipc_stream_write_uint32 (request, in_credentials_version);
}
if (!err) {
- err = k5_ipc_stream_write_time (request, in_time_offset);
+ err = krb5int_ipc_stream_write_time (request, in_time_offset);
}
if (!err) {
NULL);
}
- k5_ipc_stream_release (request);
+ krb5int_ipc_stream_release (request);
return cci_check_error (err);
}
if (!io_ccache) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_new (&request);
+ err = krb5int_ipc_stream_new (&request);
}
if (!err) {
- err = k5_ipc_stream_write_uint32 (request, in_credentials_version);
+ err = krb5int_ipc_stream_write_uint32 (request, in_credentials_version);
}
if (!err) {
NULL);
}
- k5_ipc_stream_release (request);
+ krb5int_ipc_stream_release (request);
return cci_check_error (err);
}
err = cci_ccache_new (out_ccache, identifier);
}
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (reply);
cci_identifier_release (identifier);
return cci_check_error (err);
}
cci_identifier_release (identifier);
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (reply);
return cci_check_error (err);
}
NULL, &reply);
}
- if (!err && k5_ipc_stream_size (reply) > 0) {
+ if (!err && krb5int_ipc_stream_size (reply) > 0) {
cc_time_t change_time = 0;
/* got a response from the server */
- err = k5_ipc_stream_read_time (reply, &change_time);
+ err = krb5int_ipc_stream_read_time (reply, &change_time);
if (!err) {
err = cci_context_change_time_update (context->identifier,
err = cci_context_change_time_get (out_change_time);
}
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (reply);
return cci_check_error (err);
}
if (!in_context) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_new (&request);
+ err = krb5int_ipc_stream_new (&request);
}
if (!err) {
- err = k5_ipc_stream_write_time (request, context->last_wait_for_change_time);
+ err = krb5int_ipc_stream_write_time (request, context->last_wait_for_change_time);
}
if (!err) {
}
if (!err) {
- err = k5_ipc_stream_read_time (reply, &context->last_wait_for_change_time);
+ err = krb5int_ipc_stream_read_time (reply, &context->last_wait_for_change_time);
}
- k5_ipc_stream_release (request);
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (request);
+ krb5int_ipc_stream_release (reply);
return cci_check_error (err);
}
}
if (!err) {
- if (k5_ipc_stream_size (reply) > 0) {
+ if (krb5int_ipc_stream_size (reply) > 0) {
/* got a response from the server */
- err = k5_ipc_stream_read_string (reply, &reply_name);
+ err = krb5int_ipc_stream_read_string (reply, &reply_name);
if (!err) {
name = reply_name;
err = cci_string_new (out_name, name);
}
- k5_ipc_stream_release (reply);
- k5_ipc_stream_free_string (reply_name);
+ krb5int_ipc_stream_release (reply);
+ krb5int_ipc_stream_free_string (reply_name);
return cci_check_error (err);
}
if (!out_ccache ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_new (&request);
+ err = krb5int_ipc_stream_new (&request);
}
if (!err) {
- err = k5_ipc_stream_write_string (request, in_name);
+ err = krb5int_ipc_stream_write_string (request, in_name);
}
if (!err) {
&reply);
}
- if (!err && !(k5_ipc_stream_size (reply) > 0)) {
+ if (!err && !(krb5int_ipc_stream_size (reply) > 0)) {
err = ccErrCCacheNotFound;
}
}
cci_identifier_release (identifier);
- k5_ipc_stream_release (reply);
- k5_ipc_stream_release (request);
+ krb5int_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (request);
return cci_check_error (err);
}
&reply);
}
- if (!err && !(k5_ipc_stream_size (reply) > 0)) {
+ if (!err && !(krb5int_ipc_stream_size (reply) > 0)) {
err = ccErrCCacheNotFound;
}
}
cci_identifier_release (identifier);
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (reply);
return cci_check_error (err);
}
if (!out_ccache ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_new (&request);
+ err = krb5int_ipc_stream_new (&request);
}
if (!err) {
- err = k5_ipc_stream_write_string (request, in_name);
+ err = krb5int_ipc_stream_write_string (request, in_name);
}
if (!err) {
- err = k5_ipc_stream_write_uint32 (request, in_cred_vers);
+ err = krb5int_ipc_stream_write_uint32 (request, in_cred_vers);
}
if (!err) {
- err = k5_ipc_stream_write_string (request, in_principal);
+ err = krb5int_ipc_stream_write_string (request, in_principal);
}
if (!err) {
}
cci_identifier_release (identifier);
- k5_ipc_stream_release (reply);
- k5_ipc_stream_release (request);
+ krb5int_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (request);
return cci_check_error (err);
}
if (!out_ccache ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_new (&request);
+ err = krb5int_ipc_stream_new (&request);
}
if (!err) {
- err = k5_ipc_stream_write_uint32 (request, in_cred_vers);
+ err = krb5int_ipc_stream_write_uint32 (request, in_cred_vers);
}
if (!err) {
- err = k5_ipc_stream_write_string (request, in_principal);
+ err = krb5int_ipc_stream_write_string (request, in_principal);
}
if (!err) {
}
cci_identifier_release (identifier);
- k5_ipc_stream_release (reply);
- k5_ipc_stream_release (request);
+ krb5int_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (request);
return cci_check_error (err);
}
if (!out_ccache ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_new (&request);
+ err = krb5int_ipc_stream_new (&request);
}
if (!err) {
- err = k5_ipc_stream_write_uint32 (request, in_cred_vers);
+ err = krb5int_ipc_stream_write_uint32 (request, in_cred_vers);
}
if (!err) {
- err = k5_ipc_stream_write_string (request, in_principal);
+ err = krb5int_ipc_stream_write_string (request, in_principal);
}
if (!err) {
}
cci_identifier_release (identifier);
- k5_ipc_stream_release (reply);
- k5_ipc_stream_release (request);
+ krb5int_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (request);
return cci_check_error (err);
}
}
if (!err) {
- if (k5_ipc_stream_size (reply) > 0) {
+ if (krb5int_ipc_stream_size (reply) > 0) {
err = cci_identifier_read (&identifier, reply);
} else {
identifier = cci_identifier_uninitialized;
err = cci_ccache_iterator_new (out_iterator, identifier);
}
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (reply);
cci_identifier_release (identifier);
return cci_check_error (err);
if (!in_context) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_new (&request);
+ err = krb5int_ipc_stream_new (&request);
}
if (!err) {
- err = k5_ipc_stream_write_uint32 (request, in_lock_type);
+ err = krb5int_ipc_stream_write_uint32 (request, in_lock_type);
}
if (!err) {
- err = k5_ipc_stream_write_uint32 (request, in_block);
+ err = krb5int_ipc_stream_write_uint32 (request, in_block);
}
if (!err) {
NULL);
}
- k5_ipc_stream_release (request);
+ krb5int_ipc_stream_release (request);
return cci_check_error (err);
}
}
if (!err) {
- if (k5_ipc_stream_size (reply) > 0) {
+ if (krb5int_ipc_stream_size (reply) > 0) {
err = cci_identifier_read (&new_identifier, reply);
} else {
new_identifier = cci_identifier_uninitialized;
}
cci_identifier_release (new_identifier);
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (reply);
return cci_check_error (err);
}
err = cci_credentials_read (out_credentials, reply);
}
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (reply);
return cci_check_error (err);
}
err = cci_credentials_iterator_new (out_credentials_iterator, identifier);
}
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (reply);
cci_identifier_release (identifier);
return cci_check_error (err);
}
if (!err && in_request_data) {
- err = k5_ipc_stream_write (request,
- k5_ipc_stream_data (in_request_data),
- k5_ipc_stream_size (in_request_data));
+ err = krb5int_ipc_stream_write (request,
+ krb5int_ipc_stream_data (in_request_data),
+ krb5int_ipc_stream_size (in_request_data));
}
if (!err) {
err = cci_os_ipc (in_launch_server, request, &reply);
- if (!err && k5_ipc_stream_size (reply) > 0) {
+ if (!err && krb5int_ipc_stream_size (reply) > 0) {
err = cci_message_read_reply_header (reply, &reply_error);
}
}
reply = NULL; /* take ownership */
}
- k5_ipc_stream_release (request);
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (request);
+ krb5int_ipc_stream_release (reply);
return cci_check_error (err);
}
in_msg, /* Message type */
(unsigned char*)&ptspdata, /* Our tspdata* will be sent back to the reply proc. */
(unsigned char*)uuid,
- k5_ipc_stream_size(in_request_stream),
- (unsigned char*)k5_ipc_stream_data(in_request_stream), /* Data buffer */
+ krb5int_ipc_stream_size(in_request_stream),
+ (unsigned char*)krb5int_ipc_stream_data(in_request_stream), /* Data buffer */
sst, /* session start time */
(long*)(&err) ); /* Return code */
}
}
return status;
- }
\ No newline at end of file
+ }
cci_debug_printf("%s! msg#:%d SST:%ld uuid:%s", __FUNCTION__, rpcmsg, srvStartTime, uuid);
#endif
if (!status) {
- status = k5_ipc_stream_new (&stream); /* Create a stream for the request data */
+ status = krb5int_ipc_stream_new (&stream); /* Create a stream for the request data */
}
if (!status) { /* Put the data into the stream */
- status = k5_ipc_stream_write (stream, chIn, cbIn);
+ status = krb5int_ipc_stream_write (stream, chIn, cbIn);
}
if (!status) { /* Put the data into the stream */
cci_os_ipc\r
cci_os_ipc_msg\r
cci_os_ipc_thread_init\r
- k5_ipc_stream_data\r
- k5_ipc_stream_write\r
- k5_ipc_stream_new\r
+ krb5int_ipc_stream_data\r
+ krb5int_ipc_stream_write\r
+ krb5int_ipc_stream_new\r
\r
ccs_authenticate\r
\r
}
if (!err) {
- err = k5_ipc_stream_new (&reply_data);
+ err = krb5int_ipc_stream_new (&reply_data);
}
if (!err) {
- err = k5_ipc_stream_write_time (reply_data, io_cache_collection->last_changed_time);
+ err = krb5int_ipc_stream_write_time (reply_data, io_cache_collection->last_changed_time);
}
if (!err) {
err = ccs_os_notify_cache_collection_changed (io_cache_collection);
}
- k5_ipc_stream_release (reply_data);
+ krb5int_ipc_stream_release (reply_data);
return cci_check_error (err);
}
if (!io_reply_data ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_write_time (io_reply_data, io_cache_collection->last_changed_time);
+ err = krb5int_ipc_stream_write_time (io_reply_data, io_cache_collection->last_changed_time);
}
return cci_check_error (err);
if (!out_will_block ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_read_time (in_request_data, &last_wait_for_change_time);
+ err = krb5int_ipc_stream_read_time (in_request_data, &last_wait_for_change_time);
}
if (!err) {
if (last_wait_for_change_time < io_cache_collection->last_changed_time) {
- err = k5_ipc_stream_write_time (io_reply_data, io_cache_collection->last_changed_time);
+ err = krb5int_ipc_stream_write_time (io_reply_data, io_cache_collection->last_changed_time);
} else {
ccs_callback_t callback = NULL;
err = ccs_ccache_write_name (ccache, io_reply_data);
}
} else {
- err = k5_ipc_stream_write_string (io_reply_data,
+ err = krb5int_ipc_stream_write_string (io_reply_data,
k_cci_context_initial_ccache_name);
}
}
if (!io_reply_data ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_read_string (in_request_data, &name);
+ err = krb5int_ipc_stream_read_string (in_request_data, &name);
}
if (!err) {
err = ccs_ccache_write (ccache, io_reply_data);
}
- k5_ipc_stream_free_string (name);
+ krb5int_ipc_stream_free_string (name);
return cci_check_error (err);
}
if (!io_reply_data ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_read_string (in_request_data, &name);
+ err = krb5int_ipc_stream_read_string (in_request_data, &name);
}
if (!err) {
- err = k5_ipc_stream_read_uint32 (in_request_data, &cred_vers);
+ err = krb5int_ipc_stream_read_uint32 (in_request_data, &cred_vers);
}
if (!err) {
- err = k5_ipc_stream_read_string (in_request_data, &principal);
+ err = krb5int_ipc_stream_read_string (in_request_data, &principal);
}
if (!err) {
err = ccs_cache_collection_changed (io_cache_collection);
}
- k5_ipc_stream_free_string (name);
- k5_ipc_stream_free_string (principal);
+ krb5int_ipc_stream_free_string (name);
+ krb5int_ipc_stream_free_string (principal);
return cci_check_error (err);
}
if (!io_reply_data ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_read_uint32 (in_request_data, &cred_vers);
+ err = krb5int_ipc_stream_read_uint32 (in_request_data, &cred_vers);
}
if (!err) {
- err = k5_ipc_stream_read_string (in_request_data, &principal);
+ err = krb5int_ipc_stream_read_string (in_request_data, &principal);
}
if (!err) {
err = ccs_cache_collection_changed (io_cache_collection);
}
- k5_ipc_stream_free_string (principal);
+ krb5int_ipc_stream_free_string (principal);
return cci_check_error (err);
}
if (!io_reply_data ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_read_uint32 (in_request_data, &cred_vers);
+ err = krb5int_ipc_stream_read_uint32 (in_request_data, &cred_vers);
}
if (!err) {
- err = k5_ipc_stream_read_string (in_request_data, &principal);
+ err = krb5int_ipc_stream_read_string (in_request_data, &principal);
}
if (!err) {
}
free (name);
- k5_ipc_stream_free_string (principal);
+ krb5int_ipc_stream_free_string (principal);
return cci_check_error (err);
}
if (!io_reply_data ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_read_uint32 (in_request_data, &lock_type);
+ err = krb5int_ipc_stream_read_uint32 (in_request_data, &lock_type);
}
if (!err) {
- err = k5_ipc_stream_read_uint32 (in_request_data, &block);
+ err = krb5int_ipc_stream_read_uint32 (in_request_data, &block);
}
if (!err) {
if (!out_reply_data ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_new (&reply_data);
+ err = krb5int_ipc_stream_new (&reply_data);
}
if (!err) {
}
}
- k5_ipc_stream_release (reply_data);
+ krb5int_ipc_stream_release (reply_data);
return cci_check_error (err);
}
}
if (!err) {
- err = k5_ipc_stream_new (&reply_data);
+ err = krb5int_ipc_stream_new (&reply_data);
}
if (!err) {
- err = k5_ipc_stream_write_time (reply_data, io_ccache->last_changed_time);
+ err = krb5int_ipc_stream_write_time (reply_data, io_ccache->last_changed_time);
}
if (!err) {
io_ccache->name);
}
- k5_ipc_stream_release (reply_data);
+ krb5int_ipc_stream_release (reply_data);
return cci_check_error (err);
}
if (!io_stream) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_write_string (io_stream, in_ccache->name);
+ err = krb5int_ipc_stream_write_string (io_stream, in_ccache->name);
}
return cci_check_error (err);
if (!io_reply_data ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_write_uint32 (io_reply_data, io_ccache->creds_version);
+ err = krb5int_ipc_stream_write_uint32 (io_reply_data, io_ccache->creds_version);
}
return cci_check_error (err);
if (!io_reply_data ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_write_string (io_reply_data, io_ccache->name);
+ err = krb5int_ipc_stream_write_string (io_reply_data, io_ccache->name);
}
return cci_check_error (err);
if (!io_reply_data ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_read_uint32 (in_request_data, &version);
+ err = krb5int_ipc_stream_read_uint32 (in_request_data, &version);
}
if (!err && version == cc_credentials_v4_v5) {
if (!err) {
if (version == cc_credentials_v4) {
- err = k5_ipc_stream_write_string (io_reply_data, io_ccache->v4_principal);
+ err = krb5int_ipc_stream_write_string (io_reply_data, io_ccache->v4_principal);
} else if (version == cc_credentials_v5) {
- err = k5_ipc_stream_write_string (io_reply_data, io_ccache->v5_principal);
+ err = krb5int_ipc_stream_write_string (io_reply_data, io_ccache->v5_principal);
} else {
err = cci_check_error (ccErrBadCredentialsVersion);
if (!io_reply_data ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_read_uint32 (in_request_data, &version);
+ err = krb5int_ipc_stream_read_uint32 (in_request_data, &version);
}
if (!err) {
- err = k5_ipc_stream_read_string (in_request_data, &principal);
+ err = krb5int_ipc_stream_read_string (in_request_data, &principal);
}
if (!err) {
err = ccs_ccache_changed (io_ccache, io_cache_collection);
}
- k5_ipc_stream_free_string (principal);
+ krb5int_ipc_stream_free_string (principal);
return cci_check_error (err);
}
if (!io_reply_data ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_read_uint32 (in_request_data, &lock_type);
+ err = krb5int_ipc_stream_read_uint32 (in_request_data, &lock_type);
}
if (!err) {
- err = k5_ipc_stream_read_uint32 (in_request_data, &block);
+ err = krb5int_ipc_stream_read_uint32 (in_request_data, &block);
}
if (!err) {
}
if (!err) {
- err = k5_ipc_stream_write_time (io_reply_data, io_ccache->last_default_time);
+ err = krb5int_ipc_stream_write_time (io_reply_data, io_ccache->last_default_time);
}
return cci_check_error (err);
if (!io_reply_data ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_write_time (io_reply_data, io_ccache->last_changed_time);
+ err = krb5int_ipc_stream_write_time (io_reply_data, io_ccache->last_changed_time);
}
return cci_check_error (err);
if (!out_will_block ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_read_time (in_request_data, &last_wait_for_change_time);
+ err = krb5int_ipc_stream_read_time (in_request_data, &last_wait_for_change_time);
}
if (!err) {
if (last_wait_for_change_time < io_ccache->last_changed_time) {
cci_debug_printf ("%s returning immediately", __FUNCTION__);
- err = k5_ipc_stream_write_time (io_reply_data, io_ccache->last_changed_time);
+ err = krb5int_ipc_stream_write_time (io_reply_data, io_ccache->last_changed_time);
} else {
ccs_callback_t callback = NULL;
if (!io_reply_data ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_read_uint32 (in_request_data, &cred_vers);
+ err = krb5int_ipc_stream_read_uint32 (in_request_data, &cred_vers);
}
if (!err) {
if (cred_vers == cc_credentials_v4) {
if (io_ccache->kdc_time_offset_v4_valid) {
- err = k5_ipc_stream_write_time (io_reply_data, io_ccache->kdc_time_offset_v4);
+ err = krb5int_ipc_stream_write_time (io_reply_data, io_ccache->kdc_time_offset_v4);
} else {
err = cci_check_error (ccErrTimeOffsetNotSet);
}
} else if (cred_vers == cc_credentials_v5) {
if (io_ccache->kdc_time_offset_v5_valid) {
- err = k5_ipc_stream_write_time (io_reply_data, io_ccache->kdc_time_offset_v5);
+ err = krb5int_ipc_stream_write_time (io_reply_data, io_ccache->kdc_time_offset_v5);
} else {
err = cci_check_error (ccErrTimeOffsetNotSet);
}
if (!io_reply_data ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_read_uint32 (in_request_data, &cred_vers);
+ err = krb5int_ipc_stream_read_uint32 (in_request_data, &cred_vers);
}
if (!err) {
if (cred_vers == cc_credentials_v4) {
- err = k5_ipc_stream_read_time (in_request_data, &io_ccache->kdc_time_offset_v4);
+ err = krb5int_ipc_stream_read_time (in_request_data, &io_ccache->kdc_time_offset_v4);
if (!err) {
io_ccache->kdc_time_offset_v4_valid = 1;
}
} else if (cred_vers == cc_credentials_v5) {
- err = k5_ipc_stream_read_time (in_request_data, &io_ccache->kdc_time_offset_v5);
+ err = krb5int_ipc_stream_read_time (in_request_data, &io_ccache->kdc_time_offset_v5);
if (!err) {
io_ccache->kdc_time_offset_v5_valid = 1;
if (!io_reply_data ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_read_uint32 (in_request_data, &cred_vers);
+ err = krb5int_ipc_stream_read_uint32 (in_request_data, &cred_vers);
}
if (!err) {
if (!out_reply_data ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_new (&reply_data);
+ err = krb5int_ipc_stream_new (&reply_data);
}
if (!err) {
}
}
- k5_ipc_stream_release (reply_data);
+ krb5int_ipc_stream_release (reply_data);
return cci_check_error (err);
}
if (!out_reply_data ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_new (&reply_data);
+ err = krb5int_ipc_stream_new (&reply_data);
}
if (!err) {
reply_data = NULL; /* take ownership */
}
- k5_ipc_stream_release (reply_data);
+ krb5int_ipc_stream_release (reply_data);
return cci_check_error (err);
}
if (!out_reply_data ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
- err = k5_ipc_stream_new (&reply_data);
+ err = krb5int_ipc_stream_new (&reply_data);
}
if (!err) {
reply_data = NULL; /* take ownership */
}
- k5_ipc_stream_release (reply_data);
+ krb5int_ipc_stream_release (reply_data);
return cci_check_error (err);
}
}
cci_identifier_release (request_identifier);
- k5_ipc_stream_release (reply_data);
+ krb5int_ipc_stream_release (reply_data);
return cci_check_error (err);
}
err = cci_message_new_reply_header (&reply, in_reply_err);
}
- if (!err && in_reply_data && k5_ipc_stream_size (in_reply_data) > 0) {
- err = k5_ipc_stream_write (reply,
- k5_ipc_stream_data (in_reply_data),
- k5_ipc_stream_size (in_reply_data));
+ if (!err && in_reply_data && krb5int_ipc_stream_size (in_reply_data) > 0) {
+ err = krb5int_ipc_stream_write (reply,
+ krb5int_ipc_stream_data (in_reply_data),
+ krb5int_ipc_stream_size (in_reply_data));
}
if (!err) {
err = ccs_os_server_send_reply (in_reply_pipe, reply);
}
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (reply);
return cci_check_error (err);
}
WorkItem::WorkItem(const WorkItem& item) : _buf(NULL), _rpcmsg(0), _pipe(NULL), _sst(0) {\r
\r
k5_ipc_stream _buf = NULL;\r
- k5_ipc_stream_new(&_buf);\r
- k5_ipc_stream_write(_buf, \r
- k5_ipc_stream_data(item.payload()),\r
- k5_ipc_stream_size(item.payload()) );\r
+ krb5int_ipc_stream_new(&_buf);\r
+ krb5int_ipc_stream_write(_buf, \r
+ krb5int_ipc_stream_data(item.payload()),\r
+ krb5int_ipc_stream_size(item.payload()) );\r
WorkItem(_buf, item._pipe, item._rpcmsg, item._sst);\r
}\r
\r
WorkItem::WorkItem() : _buf(NULL), _rpcmsg(CCMSG_INVALID), _pipe(NULL), _sst(0) { }\r
\r
WorkItem::~WorkItem() {\r
- if (_buf) k5_ipc_stream_release(_buf);\r
+ if (_buf) krb5int_ipc_stream_release(_buf);\r
if (_pipe) ccs_win_pipe_release(_pipe);\r
}\r
\r
}\r
\r
return !bEmpty;\r
- }
\ No newline at end of file
+ }\r
break;\r
case CCMSG_PING:\r
cci_debug_printf(" Processing PING");\r
- err = k5_ipc_stream_new (&stream);\r
- err = k5_ipc_stream_write(stream, "This is a test of the emergency broadcasting system", 52);\r
+ err = krb5int_ipc_stream_new (&stream);\r
+ err = krb5int_ipc_stream_write(stream, "This is a test of the emergency broadcasting system", 52);\r
err = ccs_os_server_send_reply(pipe, stream);\r
break;\r
default:\r
rpcmsg, uuid);\r
break;\r
}\r
- if (buf) k5_ipc_stream_release(buf);\r
+ if (buf) krb5int_ipc_stream_release(buf);\r
/* Don't free uuid, which was allocated here. A pointer to it is in the \r
rpcargs struct which was passed to connectionListener which will be\r
received by ccapi_listen when the client exits. ccapi_listen needs \r
(unsigned char*)&h, /* client's tspdata* */\r
(unsigned char*)uuid,\r
getMySST(),\r
- k5_ipc_stream_size(in_reply_stream), /* Length of buffer */\r
- (const unsigned char*)k5_ipc_stream_data(in_reply_stream), /* Data buffer */\r
+ krb5int_ipc_stream_size(in_reply_stream), /* Length of buffer */\r
+ (const unsigned char*)krb5int_ipc_stream_data(in_reply_stream), /* Data buffer */\r
&status ); /* Return code */\r
}\r
RpcExcept(1) {\r
status = (rpcmsg != CCMSG_REQUEST) && (rpcmsg != CCMSG_PING);
if (!status) {
- status = k5_ipc_stream_new (&stream); /* Create a stream for the request data */
+ status = krb5int_ipc_stream_new (&stream); /* Create a stream for the request data */
}
if (!status) { /* Put the data into the stream */
- status = k5_ipc_stream_write (stream, pbRequest, lenRequest);
+ status = krb5int_ipc_stream_write (stream, pbRequest, lenRequest);
}
pipe = ccs_win_pipe_new(pszUUID, *p);
if (hMap) CloseHandle(hMap);
return result;
- }
\ No newline at end of file
+ }
typedef struct k5_ipc_stream_s *k5_ipc_stream;
-int32_t k5_ipc_stream_new (k5_ipc_stream *out_stream);
+int32_t krb5int_ipc_stream_new (k5_ipc_stream *out_stream);
-uint32_t k5_ipc_stream_release (k5_ipc_stream io_stream);
+uint32_t krb5int_ipc_stream_release (k5_ipc_stream io_stream);
-uint64_t k5_ipc_stream_size (k5_ipc_stream in_stream);
+uint64_t krb5int_ipc_stream_size (k5_ipc_stream in_stream);
-const char *k5_ipc_stream_data (k5_ipc_stream in_stream);
+const char *krb5int_ipc_stream_data (k5_ipc_stream in_stream);
-uint32_t k5_ipc_stream_read (k5_ipc_stream in_stream,
- void *io_data,
- uint64_t in_size);
-uint32_t k5_ipc_stream_write (k5_ipc_stream in_stream,
- const void *in_data,
- uint64_t in_size);
+uint32_t krb5int_ipc_stream_read (k5_ipc_stream in_stream,
+ void *io_data,
+ uint64_t in_size);
+uint32_t krb5int_ipc_stream_write (k5_ipc_stream in_stream,
+ const void *in_data,
+ uint64_t in_size);
-uint32_t k5_ipc_stream_read_string (k5_ipc_stream io_stream,
- char **out_string);
-uint32_t k5_ipc_stream_write_string (k5_ipc_stream io_stream,
- const char *in_string);
-void k5_ipc_stream_free_string (char *in_string);
+uint32_t krb5int_ipc_stream_read_string (k5_ipc_stream io_stream,
+ char **out_string);
+uint32_t krb5int_ipc_stream_write_string (k5_ipc_stream io_stream,
+ const char *in_string);
+void krb5int_ipc_stream_free_string (char *in_string);
-uint32_t k5_ipc_stream_read_int32 (k5_ipc_stream io_stream,
- int32_t *out_int32);
-uint32_t k5_ipc_stream_write_int32 (k5_ipc_stream io_stream,
- int32_t in_int32);
+uint32_t krb5int_ipc_stream_read_int32 (k5_ipc_stream io_stream,
+ int32_t *out_int32);
+uint32_t krb5int_ipc_stream_write_int32 (k5_ipc_stream io_stream,
+ int32_t in_int32);
-uint32_t k5_ipc_stream_read_uint32 (k5_ipc_stream io_stream,
- uint32_t *out_uint32);
-uint32_t k5_ipc_stream_write_uint32 (k5_ipc_stream io_stream,
- uint32_t in_uint32);
+uint32_t krb5int_ipc_stream_read_uint32 (k5_ipc_stream io_stream,
+ uint32_t *out_uint32);
+uint32_t krb5int_ipc_stream_write_uint32 (k5_ipc_stream io_stream,
+ uint32_t in_uint32);
-uint32_t k5_ipc_stream_read_int64 (k5_ipc_stream io_stream,
- int64_t *out_int64);
-uint32_t k5_ipc_stream_write_int64 (k5_ipc_stream io_stream,
- int64_t in_int64);
+uint32_t krb5int_ipc_stream_read_int64 (k5_ipc_stream io_stream,
+ int64_t *out_int64);
+uint32_t krb5int_ipc_stream_write_int64 (k5_ipc_stream io_stream,
+ int64_t in_int64);
-uint32_t k5_ipc_stream_read_uint64 (k5_ipc_stream io_stream,
- uint64_t *out_uint64);
-uint32_t k5_ipc_stream_write_uint64 (k5_ipc_stream io_stream,
- uint64_t in_uint64);
+uint32_t krb5int_ipc_stream_read_uint64 (k5_ipc_stream io_stream,
+ uint64_t *out_uint64);
+uint32_t krb5int_ipc_stream_write_uint64 (k5_ipc_stream io_stream,
+ uint64_t in_uint64);
#endif /* K5_IPC_STREAM_H */
bool isFrontProcess = 0;
if (!err) {
- err = k5_ipc_stream_read_int32 (in_request_stream, &pid);
+ err = krb5int_ipc_stream_read_int32 (in_request_stream, &pid);
}
if (!err) {
- err = k5_ipc_stream_read_string (in_request_stream, &name);
+ err = krb5int_ipc_stream_read_string (in_request_stream, &name);
}
if (!err) {
- err = k5_ipc_stream_read_string (in_request_stream, &path);
+ err = krb5int_ipc_stream_read_string (in_request_stream, &path);
}
path:path];
}
- k5_ipc_stream_free_string (name);
- k5_ipc_stream_free_string (path);
+ krb5int_ipc_stream_free_string (name);
+ krb5int_ipc_stream_free_string (path);
return err;
}
k5_ipc_stream reply = NULL;
if (!err) {
- err = k5_ipc_stream_new (&reply);
+ err = krb5int_ipc_stream_new (&reply);
}
if (!err) {
- err = k5_ipc_stream_write_int32 (reply, in_error);
+ err = krb5int_ipc_stream_write_int32 (reply, in_error);
}
if (!err) {
err = k5_ipc_server_send_reply (in_reply_port, reply);
}
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (reply);
return err;
}
}
if (!err) {
- err = k5_ipc_stream_new (&reply);
+ err = krb5int_ipc_stream_new (&reply);
}
if (!err) {
- err = k5_ipc_stream_write_int32 (reply, in_error);
+ err = krb5int_ipc_stream_write_int32 (reply, in_error);
}
if (!err && !in_error) {
- err = k5_ipc_stream_write_string (reply, identity_string);
+ err = krb5int_ipc_stream_write_string (reply, identity_string);
}
if (!err && !in_error) {
- err = k5_ipc_stream_write_uint32 (reply, in_change_password);
+ err = krb5int_ipc_stream_write_uint32 (reply, in_change_password);
}
if (!err && !in_error) {
}
kim_string_free (&identity_string);
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (reply);
return err;
}
}
if (!err) {
- err = k5_ipc_stream_new (&reply);
+ err = krb5int_ipc_stream_new (&reply);
}
if (!err) {
- err = k5_ipc_stream_write_int32 (reply, in_error);
+ err = krb5int_ipc_stream_write_int32 (reply, in_error);
}
if (!err && !in_error) {
- err = k5_ipc_stream_write_string (reply, identity_string);
+ err = krb5int_ipc_stream_write_string (reply, identity_string);
}
if (!err && !in_error) {
- err = k5_ipc_stream_write_uint32 (reply, in_change_password);
+ err = krb5int_ipc_stream_write_uint32 (reply, in_change_password);
}
if (!err && !in_error) {
}
kim_string_free (&identity_string);
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (reply);
return err;
}
char *description = NULL;
if (!err) {
- err = k5_ipc_stream_read_string (in_request_stream, &identity_string);
+ err = krb5int_ipc_stream_read_string (in_request_stream, &identity_string);
}
if (!err) {
- err = k5_ipc_stream_read_int32 (in_request_stream, &type);
+ err = krb5int_ipc_stream_read_int32 (in_request_stream, &type);
}
if (!err) {
- err = k5_ipc_stream_read_int32 (in_request_stream, &allow_save_reply);
+ err = krb5int_ipc_stream_read_int32 (in_request_stream, &allow_save_reply);
}
if (!err) {
- err = k5_ipc_stream_read_int32 (in_request_stream, &hide_reply);
+ err = krb5int_ipc_stream_read_int32 (in_request_stream, &hide_reply);
}
if (!err) {
- err = k5_ipc_stream_read_string (in_request_stream, &title);
+ err = krb5int_ipc_stream_read_string (in_request_stream, &title);
}
if (!err) {
- err = k5_ipc_stream_read_string (in_request_stream, &message);
+ err = krb5int_ipc_stream_read_string (in_request_stream, &message);
}
if (!err) {
- err = k5_ipc_stream_read_string (in_request_stream, &description);
+ err = krb5int_ipc_stream_read_string (in_request_stream, &description);
}
if (!err) {
description:description];
}
- k5_ipc_stream_free_string (identity_string);
- k5_ipc_stream_free_string (title);
- k5_ipc_stream_free_string (message);
- k5_ipc_stream_free_string (description);
+ krb5int_ipc_stream_free_string (identity_string);
+ krb5int_ipc_stream_free_string (title);
+ krb5int_ipc_stream_free_string (message);
+ krb5int_ipc_stream_free_string (description);
return err;
}
k5_ipc_stream reply = NULL;
if (!err) {
- err = k5_ipc_stream_new (&reply);
+ err = krb5int_ipc_stream_new (&reply);
}
if (!err) {
- err = k5_ipc_stream_write_int32 (reply, in_error);
+ err = krb5int_ipc_stream_write_int32 (reply, in_error);
}
if (!err && !in_error) {
- err = k5_ipc_stream_write_string (reply, in_prompt_response);
+ err = krb5int_ipc_stream_write_string (reply, in_prompt_response);
}
if (!err && !in_error) {
- err = k5_ipc_stream_write_int32 (reply, in_allow_save_response);
+ err = krb5int_ipc_stream_write_int32 (reply, in_allow_save_response);
}
if (!err) {
err = k5_ipc_server_send_reply (in_reply_port, reply);
}
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (reply);
return err;
}
int32_t old_password_expired = 0;
if (!err) {
- err = k5_ipc_stream_read_string (in_request_stream, &identity_string);
+ err = krb5int_ipc_stream_read_string (in_request_stream, &identity_string);
}
if (!err) {
- err = k5_ipc_stream_read_int32 (in_request_stream,
+ err = krb5int_ipc_stream_read_int32 (in_request_stream,
&old_password_expired);
}
expired:old_password_expired];
}
- k5_ipc_stream_free_string (identity_string);
+ krb5int_ipc_stream_free_string (identity_string);
return err;
}
k5_ipc_stream reply = NULL;
if (!err) {
- err = k5_ipc_stream_new (&reply);
+ err = krb5int_ipc_stream_new (&reply);
}
if (!err) {
- err = k5_ipc_stream_write_int32 (reply, in_error);
+ err = krb5int_ipc_stream_write_int32 (reply, in_error);
}
if (!err && !in_error) {
- err = k5_ipc_stream_write_string (reply, in_old_password);
+ err = krb5int_ipc_stream_write_string (reply, in_old_password);
}
if (!err && !in_error) {
- err = k5_ipc_stream_write_string (reply, in_new_password);
+ err = krb5int_ipc_stream_write_string (reply, in_new_password);
}
if (!err && !in_error) {
- err = k5_ipc_stream_write_string (reply, in_vfy_password);
+ err = krb5int_ipc_stream_write_string (reply, in_vfy_password);
}
if (!err) {
err = k5_ipc_server_send_reply (in_reply_port, reply);
}
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (reply);
return err;
}
char *description = NULL;
if (!err) {
- err = k5_ipc_stream_read_string (in_request_stream, &identity_string);
+ err = krb5int_ipc_stream_read_string (in_request_stream, &identity_string);
/* Can be empty string "" if there is no identity */
if (!err && !identity_string[0]) {
- k5_ipc_stream_free_string (identity_string);
+ krb5int_ipc_stream_free_string (identity_string);
identity_string = NULL;
}
}
if (!err) {
- err = k5_ipc_stream_read_int32 (in_request_stream, &error);
+ err = krb5int_ipc_stream_read_int32 (in_request_stream, &error);
}
if (!err) {
- err = k5_ipc_stream_read_string (in_request_stream, &message);
+ err = krb5int_ipc_stream_read_string (in_request_stream, &message);
}
if (!err) {
- err = k5_ipc_stream_read_string (in_request_stream, &description);
+ err = krb5int_ipc_stream_read_string (in_request_stream, &description);
}
if (!err) {
description:description];
}
- k5_ipc_stream_free_string (identity_string);
- k5_ipc_stream_free_string (message);
- k5_ipc_stream_free_string (description);
+ krb5int_ipc_stream_free_string (identity_string);
+ krb5int_ipc_stream_free_string (message);
+ krb5int_ipc_stream_free_string (description);
return err;
}
k5_ipc_stream reply = NULL;
if (!err) {
- err = k5_ipc_stream_new (&reply);
+ err = krb5int_ipc_stream_new (&reply);
}
if (!err) {
- err = k5_ipc_stream_write_int32 (reply, in_error);
+ err = krb5int_ipc_stream_write_int32 (reply, in_error);
}
if (!err) {
err = k5_ipc_server_send_reply (in_reply_port, reply);
}
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (reply);
return err;
}
k5_ipc_stream reply = NULL;
if (!err) {
- err = k5_ipc_stream_new (&reply);
+ err = krb5int_ipc_stream_new (&reply);
}
if (!err) {
- err = k5_ipc_stream_write_int32 (reply, in_error);
+ err = krb5int_ipc_stream_write_int32 (reply, in_error);
}
if (!err) {
err = k5_ipc_server_send_reply (in_reply_port, reply);
}
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (reply);
return err;
}
char *message_type = NULL;
if (!err) {
- err = k5_ipc_stream_read_string (in_request_stream, &message_type);
+ err = krb5int_ipc_stream_read_string (in_request_stream, &message_type);
}
if (!err) {
}
}
- k5_ipc_stream_free_string (message_type);
+ krb5int_ipc_stream_free_string (message_type);
return err;
}
}
if (!err) {
- err = k5_ipc_stream_write_int64 (io_stream, options->start_time);
+ err = krb5int_ipc_stream_write_int64 (io_stream, options->start_time);
}
if (!err) {
- err = k5_ipc_stream_write_int64 (io_stream, options->lifetime);
+ err = krb5int_ipc_stream_write_int64 (io_stream, options->lifetime);
}
if (!err) {
- err = k5_ipc_stream_write_int32 (io_stream, options->renewable);
+ err = krb5int_ipc_stream_write_int32 (io_stream, options->renewable);
}
if (!err) {
- err = k5_ipc_stream_write_int64 (io_stream,
+ err = krb5int_ipc_stream_write_int64 (io_stream,
options->renewal_lifetime);
}
if (!err) {
- err = k5_ipc_stream_write_int32 (io_stream, options->forwardable);
+ err = krb5int_ipc_stream_write_int32 (io_stream, options->forwardable);
}
if (!err) {
- err = k5_ipc_stream_write_int32 (io_stream, options->proxiable);
+ err = krb5int_ipc_stream_write_int32 (io_stream, options->proxiable);
}
if (!err) {
- err = k5_ipc_stream_write_int32 (io_stream, options->addressless);
+ err = krb5int_ipc_stream_write_int32 (io_stream, options->addressless);
}
if (!err) {
- err = k5_ipc_stream_write_string (io_stream, options->service_name);
+ err = krb5int_ipc_stream_write_string (io_stream, options->service_name);
}
if (options != in_options) { kim_options_free (&options); }
if (!err && !io_stream ) { err = check_error (KIM_NULL_PARAMETER_ERR); }
if (!err) {
- err = k5_ipc_stream_read_int64 (io_stream, &io_options->start_time);
+ err = krb5int_ipc_stream_read_int64 (io_stream, &io_options->start_time);
}
if (!err) {
- err = k5_ipc_stream_read_int64 (io_stream, &io_options->lifetime);
+ err = krb5int_ipc_stream_read_int64 (io_stream, &io_options->lifetime);
}
if (!err) {
- err = k5_ipc_stream_read_int32 (io_stream, &io_options->renewable);
+ err = krb5int_ipc_stream_read_int32 (io_stream, &io_options->renewable);
}
if (!err) {
- err = k5_ipc_stream_read_int64 (io_stream,
+ err = krb5int_ipc_stream_read_int64 (io_stream,
&io_options->renewal_lifetime);
}
if (!err) {
- err = k5_ipc_stream_read_int32 (io_stream, &io_options->forwardable);
+ err = krb5int_ipc_stream_read_int32 (io_stream, &io_options->forwardable);
}
if (!err) {
- err = k5_ipc_stream_read_int32 (io_stream, &io_options->proxiable);
+ err = krb5int_ipc_stream_read_int32 (io_stream, &io_options->proxiable);
}
if (!err) {
- err = k5_ipc_stream_read_int32 (io_stream, &io_options->addressless);
+ err = krb5int_ipc_stream_read_int32 (io_stream, &io_options->addressless);
}
if (!err) {
char *service_name = NULL;
- err = k5_ipc_stream_read_string (io_stream, &service_name);
+ err = krb5int_ipc_stream_read_string (io_stream, &service_name);
if (!err) {
kim_string_free (&io_options->service_name);
}
}
- k5_ipc_stream_free_string (service_name);
+ krb5int_ipc_stream_free_string (service_name);
}
return check_error (err);
if (!err && !io_stream ) { err = check_error (KIM_NULL_PARAMETER_ERR); }
if (!err) {
- err = k5_ipc_stream_write_string (io_stream,
- in_selection_hints->application_identifier);
+ err = krb5int_ipc_stream_write_string (io_stream,
+ in_selection_hints->application_identifier);
}
if (!err) {
- err = k5_ipc_stream_write_string (io_stream,
- in_selection_hints->explanation);
+ err = krb5int_ipc_stream_write_string (io_stream,
+ in_selection_hints->explanation);
}
if (!err) {
}
if (!err) {
- err = k5_ipc_stream_write_string (io_stream,
- in_selection_hints->service_identity);
+ err = krb5int_ipc_stream_write_string (io_stream,
+ in_selection_hints->service_identity);
}
if (!err) {
- err = k5_ipc_stream_write_string (io_stream,
- in_selection_hints->client_realm);
+ err = krb5int_ipc_stream_write_string (io_stream,
+ in_selection_hints->client_realm);
}
if (!err) {
- err = k5_ipc_stream_write_string (io_stream,
- in_selection_hints->user);
+ err = krb5int_ipc_stream_write_string (io_stream,
+ in_selection_hints->user);
}
if (!err) {
- err = k5_ipc_stream_write_string (io_stream,
- in_selection_hints->service_realm);
+ err = krb5int_ipc_stream_write_string (io_stream,
+ in_selection_hints->service_realm);
}
if (!err) {
- err = k5_ipc_stream_write_string (io_stream,
- in_selection_hints->service);
+ err = krb5int_ipc_stream_write_string (io_stream,
+ in_selection_hints->service);
}
if (!err) {
- err = k5_ipc_stream_write_string (io_stream,
- in_selection_hints->server);
+ err = krb5int_ipc_stream_write_string (io_stream,
+ in_selection_hints->server);
}
return check_error (err);
if (!err) {
char *application_identifier = NULL;
- err = k5_ipc_stream_read_string (io_stream, &application_identifier);
+ err = krb5int_ipc_stream_read_string (io_stream, &application_identifier);
if (!err) {
err = kim_string_copy (&io_selection_hints->application_identifier,
application_identifier);
}
- k5_ipc_stream_free_string (application_identifier);
+ krb5int_ipc_stream_free_string (application_identifier);
}
if (!err) {
char *explanation = NULL;
- err = k5_ipc_stream_read_string (io_stream, &explanation);
+ err = krb5int_ipc_stream_read_string (io_stream, &explanation);
if (!err) {
err = kim_string_copy (&io_selection_hints->explanation,
explanation);
}
- k5_ipc_stream_free_string (explanation);
+ krb5int_ipc_stream_free_string (explanation);
}
if (!err) {
if (!err) {
char *service_identity = NULL;
- err = k5_ipc_stream_read_string (io_stream, &service_identity);
+ err = krb5int_ipc_stream_read_string (io_stream, &service_identity);
if (!err) {
err = kim_string_copy (&io_selection_hints->service_identity,
service_identity);
}
- k5_ipc_stream_free_string (service_identity);
+ krb5int_ipc_stream_free_string (service_identity);
}
if (!err) {
char *client_realm = NULL;
- err = k5_ipc_stream_read_string (io_stream, &client_realm);
+ err = krb5int_ipc_stream_read_string (io_stream, &client_realm);
if (!err) {
err = kim_string_copy (&io_selection_hints->client_realm,
client_realm);
}
- k5_ipc_stream_free_string (client_realm);
+ krb5int_ipc_stream_free_string (client_realm);
}
if (!err) {
char *user = NULL;
- err = k5_ipc_stream_read_string (io_stream, &user);
+ err = krb5int_ipc_stream_read_string (io_stream, &user);
if (!err) {
err = kim_string_copy (&io_selection_hints->user, user);
}
- k5_ipc_stream_free_string (user);
+ krb5int_ipc_stream_free_string (user);
}
if (!err) {
char *service_realm = NULL;
- err = k5_ipc_stream_read_string (io_stream, &service_realm);
+ err = krb5int_ipc_stream_read_string (io_stream, &service_realm);
if (!err) {
err = kim_string_copy (&io_selection_hints->service_realm,
service_realm);
}
- k5_ipc_stream_free_string (service_realm);
+ krb5int_ipc_stream_free_string (service_realm);
}
if (!err) {
char *service = NULL;
- err = k5_ipc_stream_read_string (io_stream, &service);
+ err = krb5int_ipc_stream_read_string (io_stream, &service);
if (!err) {
err = kim_string_copy (&io_selection_hints->service, service);
}
- k5_ipc_stream_free_string (service);
+ krb5int_ipc_stream_free_string (service);
}
if (!err) {
char *server = NULL;
- err = k5_ipc_stream_read_string (io_stream, &server);
+ err = krb5int_ipc_stream_read_string (io_stream, &server);
if (!err) {
err = kim_string_copy (&io_selection_hints->server, server);
}
- k5_ipc_stream_free_string (server);
+ krb5int_ipc_stream_free_string (server);
}
return check_error (err);
}
if (!err) {
- err = k5_ipc_stream_new (&request);
+ err = krb5int_ipc_stream_new (&request);
}
if (!err) {
- err = k5_ipc_stream_write_string (request, "init");
+ err = krb5int_ipc_stream_write_string (request, "init");
}
if (!err) {
- err = k5_ipc_stream_write_int32 (request, getpid());
+ err = krb5int_ipc_stream_write_int32 (request, getpid());
}
if (!err) {
- err = k5_ipc_stream_write_string (request, name ? name : "");
+ err = krb5int_ipc_stream_write_string (request, name ? name : "");
}
if (!err) {
- err = k5_ipc_stream_write_string (request, path ? path : "");
+ err = krb5int_ipc_stream_write_string (request, path ? path : "");
}
if (!err) {
if (!err) {
int32_t result = 0;
- err = k5_ipc_stream_read_int32 (reply, &result);
+ err = krb5int_ipc_stream_read_int32 (reply, &result);
if (!err) { err = check_error (result); }
}
io_context->tcontext = NULL;
}
- k5_ipc_stream_release (request);
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (request);
+ krb5int_ipc_stream_release (reply);
kim_string_free (&name);
kim_string_free (&path);
if (!err && !out_change_password) { err = check_error (KIM_NULL_PARAMETER_ERR); }
if (!err) {
- err = k5_ipc_stream_new (&request);
+ err = krb5int_ipc_stream_new (&request);
}
if (!err) {
- err = k5_ipc_stream_write_string (request, "enter_identity");
+ err = krb5int_ipc_stream_write_string (request, "enter_identity");
}
if (!err) {
if (!err) {
int32_t result = 0;
- err = k5_ipc_stream_read_int32 (reply, &result);
+ err = krb5int_ipc_stream_read_int32 (reply, &result);
if (!err) { err = check_error (result); }
}
if (!err) {
- err = k5_ipc_stream_read_string (reply, &identity_string);
+ err = krb5int_ipc_stream_read_string (reply, &identity_string);
}
if (!err) {
- err = k5_ipc_stream_read_uint32 (reply, &change_password);
+ err = krb5int_ipc_stream_read_uint32 (reply, &change_password);
}
if (!err) {
}
kim_identity_free (&identity);
- k5_ipc_stream_free_string (identity_string);
- k5_ipc_stream_release (request);
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_free_string (identity_string);
+ krb5int_ipc_stream_release (request);
+ krb5int_ipc_stream_release (reply);
return check_error (err);
}
if (!err && !out_change_password) { err = check_error (KIM_NULL_PARAMETER_ERR); }
if (!err) {
- err = k5_ipc_stream_new (&request);
+ err = krb5int_ipc_stream_new (&request);
}
if (!err) {
- err = k5_ipc_stream_write_string (request, "select_identity");
+ err = krb5int_ipc_stream_write_string (request, "select_identity");
}
if (!err) {
if (!err) {
int32_t result = 0;
- err = k5_ipc_stream_read_int32 (reply, &result);
+ err = krb5int_ipc_stream_read_int32 (reply, &result);
if (!err) { err = check_error (result); }
}
if (!err) {
- err = k5_ipc_stream_read_string (reply, &identity_string);
+ err = krb5int_ipc_stream_read_string (reply, &identity_string);
}
if (!err) {
}
if (!err) {
- err = k5_ipc_stream_read_uint32 (reply, &change_password);
+ err = krb5int_ipc_stream_read_uint32 (reply, &change_password);
}
if (!err) {
kim_identity_free (&identity);
kim_options_free (&options);
- k5_ipc_stream_free_string (identity_string);
- k5_ipc_stream_release (request);
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_free_string (identity_string);
+ krb5int_ipc_stream_release (request);
+ krb5int_ipc_stream_release (reply);
return check_error (err);
}
}
if (!err) {
- err = k5_ipc_stream_new (&request);
+ err = krb5int_ipc_stream_new (&request);
}
if (!err) {
- err = k5_ipc_stream_write_string (request, "auth_prompt");
+ err = krb5int_ipc_stream_write_string (request, "auth_prompt");
}
if (!err) {
- err = k5_ipc_stream_write_string (request, identity_string);
+ err = krb5int_ipc_stream_write_string (request, identity_string);
}
if (!err) {
- err = k5_ipc_stream_write_int32 (request, in_type);
+ err = krb5int_ipc_stream_write_int32 (request, in_type);
}
if (!err) {
- err = k5_ipc_stream_write_int32 (request, in_allow_save_reply);
+ err = krb5int_ipc_stream_write_int32 (request, in_allow_save_reply);
}
if (!err) {
- err = k5_ipc_stream_write_int32 (request, in_hide_reply);
+ err = krb5int_ipc_stream_write_int32 (request, in_hide_reply);
}
if (!err) {
- err = k5_ipc_stream_write_string (request,
+ err = krb5int_ipc_stream_write_string (request,
in_title ? in_title : "");
}
if (!err) {
- err = k5_ipc_stream_write_string (request,
+ err = krb5int_ipc_stream_write_string (request,
in_message ? in_message : "");
}
if (!err) {
- err = k5_ipc_stream_write_string (request,
+ err = krb5int_ipc_stream_write_string (request,
in_description ? in_description : "");
}
if (!err) {
int32_t result = 0;
- err = k5_ipc_stream_read_int32 (reply, &result);
+ err = krb5int_ipc_stream_read_int32 (reply, &result);
if (!err) { err = check_error (result); }
}
if (!err) {
- err = k5_ipc_stream_read_string (reply, out_reply);
+ err = krb5int_ipc_stream_read_string (reply, out_reply);
}
if (!err) {
- err = k5_ipc_stream_read_int32 (reply, out_save_reply);
+ err = krb5int_ipc_stream_read_int32 (reply, out_save_reply);
}
kim_string_free (&identity_string);
- k5_ipc_stream_release (request);
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (request);
+ krb5int_ipc_stream_release (reply);
return check_error (err);
}
}
if (!err) {
- err = k5_ipc_stream_new (&request);
+ err = krb5int_ipc_stream_new (&request);
}
if (!err) {
- err = k5_ipc_stream_write_string (request, "change_password");
+ err = krb5int_ipc_stream_write_string (request, "change_password");
}
if (!err) {
- err = k5_ipc_stream_write_string (request, identity_string);
+ err = krb5int_ipc_stream_write_string (request, identity_string);
}
if (!err) {
- err = k5_ipc_stream_write_int32 (request, in_old_password_expired);
+ err = krb5int_ipc_stream_write_int32 (request, in_old_password_expired);
}
if (!err) {
if (!err) {
int32_t result = 0;
- err = k5_ipc_stream_read_int32 (reply, &result);
+ err = krb5int_ipc_stream_read_int32 (reply, &result);
if (!err) { err = check_error (result); }
}
if (!err) {
- err = k5_ipc_stream_read_string (reply, &old_password);
+ err = krb5int_ipc_stream_read_string (reply, &old_password);
}
if (!err) {
- err = k5_ipc_stream_read_string (reply, &new_password);
+ err = krb5int_ipc_stream_read_string (reply, &new_password);
}
if (!err) {
- err = k5_ipc_stream_read_string (reply, &vfy_password);
+ err = krb5int_ipc_stream_read_string (reply, &vfy_password);
}
if (!err) {
}
kim_string_free (&identity_string);
- k5_ipc_stream_free_string (old_password);
- k5_ipc_stream_free_string (new_password);
- k5_ipc_stream_free_string (vfy_password);
+ krb5int_ipc_stream_free_string (old_password);
+ krb5int_ipc_stream_free_string (new_password);
+ krb5int_ipc_stream_free_string (vfy_password);
- k5_ipc_stream_release (request);
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (request);
+ krb5int_ipc_stream_release (reply);
return check_error (err);
}
}
if (!err) {
- err = k5_ipc_stream_new (&request);
+ err = krb5int_ipc_stream_new (&request);
}
if (!err) {
- err = k5_ipc_stream_write_string (request, "handle_error");
+ err = krb5int_ipc_stream_write_string (request, "handle_error");
}
if (!err) {
- err = k5_ipc_stream_write_string (request, identity_string);
+ err = krb5int_ipc_stream_write_string (request, identity_string);
}
if (!err) {
- err = k5_ipc_stream_write_int32 (request, in_error);
+ err = krb5int_ipc_stream_write_int32 (request, in_error);
}
if (!err) {
- err = k5_ipc_stream_write_string (request, in_error_message);
+ err = krb5int_ipc_stream_write_string (request, in_error_message);
}
if (!err) {
- err = k5_ipc_stream_write_string (request, in_error_description);
+ err = krb5int_ipc_stream_write_string (request, in_error_description);
}
if (!err) {
if (!err) {
int32_t result = 0;
- err = k5_ipc_stream_read_int32 (reply, &result);
+ err = krb5int_ipc_stream_read_int32 (reply, &result);
if (!err) { err = check_error (result); }
}
kim_string_free (&identity_string);
- k5_ipc_stream_release (request);
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (request);
+ krb5int_ipc_stream_release (reply);
return check_error (err);
}
k5_ipc_stream reply = NULL;
if (!err) {
- err = k5_ipc_stream_new (&request);
+ err = krb5int_ipc_stream_new (&request);
}
if (!err) {
- err = k5_ipc_stream_write_string (request, "fini");
+ err = krb5int_ipc_stream_write_string (request, "fini");
}
if (!err) {
if (!err) {
int32_t result = 0;
- err = k5_ipc_stream_read_int32 (reply, &result);
+ err = krb5int_ipc_stream_read_int32 (reply, &result);
if (!err) { err = check_error (result); }
}
- k5_ipc_stream_release (request);
- k5_ipc_stream_release (reply);
+ krb5int_ipc_stream_release (request);
+ krb5int_ipc_stream_release (reply);
return check_error (err);
}
if (!err) {
if (in_inl_replyCnt) {
- err = k5_ipc_stream_write (cinfo->reply_stream,
- in_inl_reply, in_inl_replyCnt);
+ err = krb5int_ipc_stream_write (cinfo->reply_stream,
+ in_inl_reply, in_inl_replyCnt);
} else if (in_ool_replyCnt) {
- err = k5_ipc_stream_write (cinfo->reply_stream,
- in_ool_reply, in_ool_replyCnt);
+ err = krb5int_ipc_stream_write (cinfo->reply_stream,
+ in_ool_reply, in_ool_replyCnt);
} else {
err = EINVAL;
if (!err) {
/* depending on how big the message is, use the fast inline buffer or
* the slow dynamically allocated buffer */
- mach_msg_type_number_t request_length = k5_ipc_stream_size (in_request_stream);
+ mach_msg_type_number_t request_length = krb5int_ipc_stream_size (in_request_stream);
if (request_length > K5_IPC_MAX_INL_MSG_SIZE) {
/*dprintf ("%s choosing out of line buffer (size is %d)",
* __FUNCTION__, request_length); */
err = vm_read (mach_task_self (),
- (vm_address_t) k5_ipc_stream_data (in_request_stream),
+ (vm_address_t) krb5int_ipc_stream_data (in_request_stream),
request_length,
(vm_address_t *) &ool_request,
&ool_request_length);
* __FUNCTION__, request_length); */
inl_request_length = request_length;
- inl_request = k5_ipc_stream_data (in_request_stream);
+ inl_request = krb5int_ipc_stream_data (in_request_stream);
}
}
}
if (!err) {
- err = k5_ipc_stream_new (&cinfo->reply_stream);
+ err = krb5int_ipc_stream_new (&cinfo->reply_stream);
}
if (!err) {
(vm_address_t) ool_request, ool_request_length);
}
if (cinfo && cinfo->reply_stream) {
- k5_ipc_stream_release (cinfo->reply_stream);
+ krb5int_ipc_stream_release (cinfo->reply_stream);
cinfo->reply_stream = NULL;
}
k5_ipc_stream request_stream = NULL;
if (!err) {
- err = k5_ipc_stream_new (&request_stream);
+ err = krb5int_ipc_stream_new (&request_stream);
}
if (!err) {
if (in_inl_requestCnt) {
- err = k5_ipc_stream_write (request_stream, in_inl_request, in_inl_requestCnt);
+ err = krb5int_ipc_stream_write (request_stream, in_inl_request, in_inl_requestCnt);
} else if (in_ool_requestCnt) {
- err = k5_ipc_stream_write (request_stream, in_ool_request, in_ool_requestCnt);
+ err = krb5int_ipc_stream_write (request_stream, in_ool_request, in_ool_requestCnt);
} else {
err = EINVAL;
err = k5_ipc_server_handle_request (in_connection_port, in_reply_port, request_stream);
}
- k5_ipc_stream_release (request_stream);
+ krb5int_ipc_stream_release (request_stream);
if (in_ool_requestCnt) { vm_deallocate (mach_task_self (), (vm_address_t) in_ool_request, in_ool_requestCnt); }
return err;
if (!err) {
/* depending on how big the message is, use the fast inline buffer or
* the slow dynamically allocated buffer */
- mach_msg_type_number_t reply_length = k5_ipc_stream_size (in_reply_stream);
+ mach_msg_type_number_t reply_length = krb5int_ipc_stream_size (in_reply_stream);
if (reply_length > K5_IPC_MAX_INL_MSG_SIZE) {
//dprintf ("%s choosing out of line buffer (size is %d)",
// __FUNCTION__, reply_length);
err = vm_read (mach_task_self (),
- (vm_address_t) k5_ipc_stream_data (in_reply_stream), reply_length,
+ (vm_address_t) krb5int_ipc_stream_data (in_reply_stream), reply_length,
(vm_address_t *) &ool_reply, &ool_reply_length);
} else {
// __FUNCTION__, reply_length);
inl_reply_length = reply_length;
- memcpy (inl_reply, k5_ipc_stream_data (in_reply_stream), reply_length);
+ memcpy (inl_reply, krb5int_ipc_stream_data (in_reply_stream), reply_length);
}
}
/* ------------------------------------------------------------------------ */
-static uint32_t k5_ipc_stream_reallocate (k5_ipc_stream io_stream,
- uint64_t in_new_size)
+static uint32_t krb5int_ipc_stream_reallocate (k5_ipc_stream io_stream,
+ uint64_t in_new_size)
{
int32_t err = 0;
uint64_t new_max_size = 0;
/* ------------------------------------------------------------------------ */
-int32_t k5_ipc_stream_new (k5_ipc_stream *out_stream)
+int32_t krb5int_ipc_stream_new (k5_ipc_stream *out_stream)
{
int32_t err = 0;
k5_ipc_stream stream = NULL;
stream = NULL;
}
- k5_ipc_stream_release (stream);
+ krb5int_ipc_stream_release (stream);
return k5_check_error (err);
}
/* ------------------------------------------------------------------------ */
-uint32_t k5_ipc_stream_release (k5_ipc_stream io_stream)
+uint32_t krb5int_ipc_stream_release (k5_ipc_stream io_stream)
{
int32_t err = 0;
/* ------------------------------------------------------------------------ */
-uint64_t k5_ipc_stream_size (k5_ipc_stream in_stream)
+uint64_t krb5int_ipc_stream_size (k5_ipc_stream in_stream)
{
return in_stream ? in_stream->size : 0;
}
/* ------------------------------------------------------------------------ */
-const char *k5_ipc_stream_data (k5_ipc_stream in_stream)
+const char *krb5int_ipc_stream_data (k5_ipc_stream in_stream)
{
return in_stream ? in_stream->data : NULL;
}
/* ------------------------------------------------------------------------ */
-uint32_t k5_ipc_stream_read (k5_ipc_stream io_stream,
- void *io_data,
- uint64_t in_size)
+uint32_t krb5int_ipc_stream_read (k5_ipc_stream io_stream,
+ void *io_data,
+ uint64_t in_size)
{
int32_t err = 0;
memmove (io_stream->data, &io_stream->data[in_size],
io_stream->size - in_size);
- err = k5_ipc_stream_reallocate (io_stream, io_stream->size - in_size);
+ err = krb5int_ipc_stream_reallocate (io_stream, io_stream->size - in_size);
if (!err) {
io_stream->size -= in_size;
/* ------------------------------------------------------------------------ */
-uint32_t k5_ipc_stream_write (k5_ipc_stream io_stream,
- const void *in_data,
- uint64_t in_size)
+uint32_t krb5int_ipc_stream_write (k5_ipc_stream io_stream,
+ const void *in_data,
+ uint64_t in_size)
{
int32_t err = 0;
}
if (!err) {
- err = k5_ipc_stream_reallocate (io_stream, io_stream->size + in_size);
+ err = krb5int_ipc_stream_reallocate (io_stream, io_stream->size + in_size);
}
if (!err) {
/* ------------------------------------------------------------------------ */
-void k5_ipc_stream_free_string (char *in_string)
+void krb5int_ipc_stream_free_string (char *in_string)
{
free (in_string);
}
/* ------------------------------------------------------------------------ */
-uint32_t k5_ipc_stream_read_string (k5_ipc_stream io_stream,
- char **out_string)
+uint32_t krb5int_ipc_stream_read_string (k5_ipc_stream io_stream,
+ char **out_string)
{
int32_t err = 0;
uint32_t length = 0;
if (!out_string) { err = k5_check_error (EINVAL); }
if (!err) {
- err = k5_ipc_stream_read_uint32 (io_stream, &length);
+ err = krb5int_ipc_stream_read_uint32 (io_stream, &length);
}
if (!err) {
}
if (!err) {
- err = k5_ipc_stream_read (io_stream, string, length);
+ err = krb5int_ipc_stream_read (io_stream, string, length);
}
if (!err) {
/* ------------------------------------------------------------------------ */
-uint32_t k5_ipc_stream_write_string (k5_ipc_stream io_stream,
- const char *in_string)
+uint32_t krb5int_ipc_stream_write_string (k5_ipc_stream io_stream,
+ const char *in_string)
{
int32_t err = 0;
uint32_t length = 0;
if (!err) {
length = strlen (in_string) + 1;
- err = k5_ipc_stream_write_uint32 (io_stream, length);
+ err = krb5int_ipc_stream_write_uint32 (io_stream, length);
}
if (!err) {
- err = k5_ipc_stream_write (io_stream, in_string, length);
+ err = krb5int_ipc_stream_write (io_stream, in_string, length);
}
return k5_check_error (err);
/* ------------------------------------------------------------------------ */
-uint32_t k5_ipc_stream_read_int32 (k5_ipc_stream io_stream,
- int32_t *out_int32)
+uint32_t krb5int_ipc_stream_read_int32 (k5_ipc_stream io_stream,
+ int32_t *out_int32)
{
int32_t err = 0;
int32_t int32 = 0;
if (!out_int32) { err = k5_check_error (EINVAL); }
if (!err) {
- err = k5_ipc_stream_read (io_stream, &int32, sizeof (int32));
+ err = krb5int_ipc_stream_read (io_stream, &int32, sizeof (int32));
}
if (!err) {
/* ------------------------------------------------------------------------ */
-uint32_t k5_ipc_stream_write_int32 (k5_ipc_stream io_stream,
- int32_t in_int32)
+uint32_t krb5int_ipc_stream_write_int32 (k5_ipc_stream io_stream,
+ int32_t in_int32)
{
int32_t err = 0;
int32_t int32 = htonl (in_int32);
if (!io_stream) { err = k5_check_error (EINVAL); }
if (!err) {
- err = k5_ipc_stream_write (io_stream, &int32, sizeof (int32));
+ err = krb5int_ipc_stream_write (io_stream, &int32, sizeof (int32));
}
return k5_check_error (err);
/* ------------------------------------------------------------------------ */
-uint32_t k5_ipc_stream_read_uint32 (k5_ipc_stream io_stream,
- uint32_t *out_uint32)
+uint32_t krb5int_ipc_stream_read_uint32 (k5_ipc_stream io_stream,
+ uint32_t *out_uint32)
{
int32_t err = 0;
uint32_t uint32 = 0;
if (!out_uint32) { err = k5_check_error (EINVAL); }
if (!err) {
- err = k5_ipc_stream_read (io_stream, &uint32, sizeof (uint32));
+ err = krb5int_ipc_stream_read (io_stream, &uint32, sizeof (uint32));
}
if (!err) {
/* ------------------------------------------------------------------------ */
-uint32_t k5_ipc_stream_write_uint32 (k5_ipc_stream io_stream,
- uint32_t in_uint32)
+uint32_t krb5int_ipc_stream_write_uint32 (k5_ipc_stream io_stream,
+ uint32_t in_uint32)
{
int32_t err = 0;
int32_t uint32 = htonl (in_uint32);
if (!io_stream) { err = k5_check_error (EINVAL); }
if (!err) {
- err = k5_ipc_stream_write (io_stream, &uint32, sizeof (uint32));
+ err = krb5int_ipc_stream_write (io_stream, &uint32, sizeof (uint32));
}
return k5_check_error (err);
/* ------------------------------------------------------------------------ */
-uint32_t k5_ipc_stream_read_int64 (k5_ipc_stream io_stream,
- int64_t *out_int64)
+uint32_t krb5int_ipc_stream_read_int64 (k5_ipc_stream io_stream,
+ int64_t *out_int64)
{
int32_t err = 0;
uint64_t int64 = 0;
if (!out_int64) { err = k5_check_error (EINVAL); }
if (!err) {
- err = k5_ipc_stream_read (io_stream, &int64, sizeof (int64));
+ err = krb5int_ipc_stream_read (io_stream, &int64, sizeof (int64));
}
if (!err) {
/* ------------------------------------------------------------------------ */
-uint32_t k5_ipc_stream_write_int64 (k5_ipc_stream io_stream,
- int64_t in_int64)
+uint32_t krb5int_ipc_stream_write_int64 (k5_ipc_stream io_stream,
+ int64_t in_int64)
{
int32_t err = 0;
int64_t int64 = htonll (in_int64);
if (!io_stream) { err = k5_check_error (EINVAL); }
if (!err) {
- err = k5_ipc_stream_write (io_stream, &int64, sizeof (int64));
+ err = krb5int_ipc_stream_write (io_stream, &int64, sizeof (int64));
}
return k5_check_error (err);
/* ------------------------------------------------------------------------ */
-uint32_t k5_ipc_stream_read_uint64 (k5_ipc_stream io_stream,
- uint64_t *out_uint64)
+uint32_t krb5int_ipc_stream_read_uint64 (k5_ipc_stream io_stream,
+ uint64_t *out_uint64)
{
int32_t err = 0;
uint64_t uint64 = 0;
if (!out_uint64) { err = k5_check_error (EINVAL); }
if (!err) {
- err = k5_ipc_stream_read (io_stream, &uint64, sizeof (uint64));
+ err = krb5int_ipc_stream_read (io_stream, &uint64, sizeof (uint64));
}
if (!err) {
/* ------------------------------------------------------------------------ */
-uint32_t k5_ipc_stream_write_uint64 (k5_ipc_stream io_stream,
- uint64_t in_uint64)
+uint32_t krb5int_ipc_stream_write_uint64 (k5_ipc_stream io_stream,
+ uint64_t in_uint64)
{
int32_t err = 0;
int64_t uint64 = htonll (in_uint64);
if (!io_stream) { err = k5_check_error (EINVAL); }
if (!err) {
- err = k5_ipc_stream_write (io_stream, &uint64, sizeof (uint64));
+ err = krb5int_ipc_stream_write (io_stream, &uint64, sizeof (uint64));
}
return k5_check_error (err);
projects / krb5.git / commitdiff