3 #include <DefaultComm.h> 4 #include <comm_header.h> 7 #ifndef CISCLIENTCOMM_H_ 8 #define CISCLIENTCOMM_H_ 12 static unsigned _client_rand_seeded = 0;
20 int new_client_address(
comm_t *comm) {
21 if (!(_client_rand_seeded)) {
22 srand(ptr2seed(comm));
23 _client_rand_seeded = 1;
25 comm->
type = _default_comm;
26 return new_default_address(comm);
35 int init_client_comm(
comm_t *comm) {
37 if (!(_client_rand_seeded)) {
38 srand(ptr2seed(comm));
39 _client_rand_seeded = 1;
42 if ((strlen(comm->
name) == 0) && (strlen(comm->
address) > 0)) {
43 comm->
type = _default_comm;
44 return init_default_comm(comm);
47 char *seri_out = (
char*)malloc(strlen(comm->
direction) + 1);
48 if (seri_out == NULL) {
49 cislog_error(
"init_client_comm: Failed to malloc output serializer.");
54 if (strlen(comm->
name) == 0) {
55 handle = new_comm_base(comm->
address,
"send", _default_comm, (
void*)seri_out);
56 sprintf(handle->
name,
"client_request.%s", comm->
address);
58 handle = init_comm_base(comm->
name,
"send", _default_comm, (
void*)seri_out);
60 ret = init_default_comm(handle);
62 comm->
handle = (
void*)handle;
64 int *ncomm = (
int*)malloc(
sizeof(
int));
66 cislog_error(
"init_client_comm: Failed to malloc ncomm.");
70 handle->
info = (
void*)ncomm;
75 cislog_error(
"init_client_comm: Failed to malloc info.");
79 comm->
info = (
void*)info;
84 int get_client_response_count(
const comm_t x) {
88 out = ((
int*)(handle->
info))[0];
94 void set_client_response_count(
const comm_t x,
const int new_val) {
97 int *count = (
int*)(handle->
info);
103 void inc_client_response_count(
const comm_t x) {
105 if (handle != NULL) {
106 int *count = (
int*)(handle->
info);
112 void dec_client_response_count(
const comm_t x) {
114 if (handle != NULL) {
115 int *count = (
int*)(handle->
info);
121 void free_client_response_count(
comm_t *x) {
123 if (handle != NULL) {
124 int *count = (
int*)(handle->
info);
136 int free_client_comm(
comm_t *x) {
137 if (x->
info != NULL) {
139 if (info[0] != NULL) {
140 int ncomm = get_client_response_count(*x);
142 for (i = 0; i < ncomm; i++) {
143 if (info[0][i] != NULL) {
144 free_default_comm(info[0][i]);
145 free_comm_base(info[0][i]);
155 free_client_response_count(x);
158 char buf[100] = CIS_MSG_EOF;
159 default_comm_send(*handle, buf, strlen(buf));
161 free_default_comm(handle);
162 free_comm_base(handle);
175 int client_comm_nmsg(
const comm_t x) {
177 int ret = default_comm_nmsg(*handle);
191 int ncomm = get_client_response_count(x);
193 res_comm[0] = (
comm_t**)realloc(res_comm[0],
sizeof(
comm_t*)*(ncomm + 1));
194 if (res_comm[0] == NULL) {
195 cislog_error(
"client_response_header: Failed to realloc response comm.");
199 char *seri_copy = (
char*)malloc(strlen((
char*)(x.
serializer->
info)) + 1);
200 if (seri_copy == NULL) {
201 cislog_error(
"client_response_header: Failed to malloc copy of serializer info.");
206 res_comm[0][ncomm] = new_comm_base(NULL,
"recv", _default_comm, seri_copy);
207 int ret = new_default_address(res_comm[0][ncomm]);
209 cislog_error(
"client_response_header(%s): could not create response comm", x.
name);
213 res_comm[0][ncomm]->
sent_eof[0] = 1;
214 res_comm[0][ncomm]->
recv_eof[0] = 1;
215 inc_client_response_count(x);
216 ncomm = get_client_response_count(x);
217 cislog_debug(
"client_response_header(%s): Created response comm number %d",
222 cislog_debug(
"client_response_header(%s): response_address = %s, request_id = %s",
235 int client_comm_send(
comm_t x,
const char *data,
const size_t len) {
237 cislog_debug(
"client_comm_send(%s): %d bytes", x.
name, len);
239 cislog_error(
"client_comm_send(%s): no request comm registered", x.
name);
243 ret = default_comm_send(*req_comm, data, len);
262 int client_comm_recv(
comm_t x,
char **data,
const size_t len,
const int allow_realloc) {
263 cislog_debug(
"client_comm_recv(%s)", x.
name);
264 if ((x.
info == NULL) || (get_client_response_count(x) == 0)) {
265 cislog_error(
"client_comm_recv(%s): no response comm registered", x.
name);
269 int ret = default_comm_recv(res_comm[0][0][0], data, len, allow_realloc);
271 cislog_error(
"client_comm_recv(%s): default_comm_recv returned %d",
276 cislog_debug(
"client_comm_recv(%s): default_comm_recv returned %d",
278 free_default_comm(res_comm[0][0]);
279 free_comm_base(res_comm[0][0]);
280 free(res_comm[0][0]);
281 dec_client_response_count(x);
282 int nresp = get_client_response_count(x);
283 memmove(*res_comm, *res_comm + 1, nresp*
sizeof(
comm_t*));
void * handle
Pointer to handle for comm.
Definition: CommBase.h:25
char response_address[COMMBUFFSIZ]
Response address.
Definition: comm_header.h:23
char request_id[COMMBUFFSIZ]
Request id.
Definition: comm_header.h:24
void * info
Pointer to any extra info comm requires.
Definition: CommBase.h:26
Communication structure.
Definition: CommBase.h:19
char address[COMM_ADDRESS_SIZE]
Comm address.
Definition: CommBase.h:22
void * info
Pointer to any extra info serializer requires.
Definition: SerializeBase.h:17
comm_type type
Comm type.
Definition: CommBase.h:20
int valid
1 if the header is valid, 0 otherwise.
Definition: comm_header.h:21
int always_send_header
1 if comm should always send a header.
Definition: CommBase.h:29
seri_t * serializer
Serializer for comm messages.
Definition: CommBase.h:27
char direction[COMM_DIR_SIZE]
send or recv for direction messages will go.
Definition: CommBase.h:23
char name[COMM_NAME_SIZE]
Comm name.
Definition: CommBase.h:21
int * sent_eof
Flag specifying if EOF has been sent.
Definition: CommBase.h:32
int * recv_eof
Flag specifying if EOF has been received.
Definition: CommBase.h:33
Header information passed by comms for multipart messages.
Definition: comm_header.h:15