Initial revision
[OpenSRF.git] / src / libtransport / transport_client.c
1 #include "transport_client.h"
2
3
4 //int main( int argc, char** argv );
5
6 /*
7 int main( int argc, char** argv ) {
8
9         transport_message* recv;
10         transport_message* send;
11
12         transport_client* client = client_init( "spacely.georgialibraries.org", 5222 );
13
14         // try to connect, allow 15 second connect timeout 
15         if( client_connect( client, "admin", "asdfjkjk", "system", 15 ) ) {
16                 printf("Connected...\n");
17         } else { 
18                 printf( "NOT Connected...\n" ); exit(99); 
19         }
20
21         while( (recv = client_recv( client, -1 )) ) {
22
23                 if( recv->body ) {
24                         int len = strlen(recv->body);
25                         char buf[len + 20];
26                         memset( buf, 0, len + 20); 
27                         sprintf( buf, "Echoing...%s", recv->body );
28                         send = message_init( buf, "Echoing Stuff", "12345", recv->sender, "" );
29                 } else {
30                         send = message_init( " * ECHOING * ", "Echoing Stuff", "12345", recv->sender, "" );
31                 }
32
33                 if( send == NULL ) { printf("something's wrong"); }
34                 client_send_message( client, send );
35                                 
36                 message_free( send );
37                 message_free( recv );
38         }
39
40         printf( "ended recv loop\n" );
41
42         return 0;
43
44 }
45 */
46
47
48 transport_client* client_init( char* server, int port ) {
49
50         if(server == NULL) return NULL;
51
52         /* build and clear the client object */
53         size_t c_size = sizeof( transport_client);
54         transport_client* client = (transport_client*) safe_malloc( c_size );
55
56         /* build and clear the message list */
57         size_t l_size = sizeof( transport_message_list );
58         client->m_list = (transport_message_list*) safe_malloc( l_size );
59
60         client->m_list->type = MESSAGE_LIST_HEAD;
61         client->session = init_transport( server, port, client );
62
63
64         if(client->session == NULL) {
65                 fatal_handler( "client_init(): Out of Memory"); 
66                 return NULL;
67         }
68         client->session->message_callback = client_message_handler;
69
70         return client;
71 }
72
73 int client_connect( transport_client* client, 
74                 char* username, char* password, char* resource, int connect_timeout ) {
75         if(client == NULL) return 0; 
76         return session_connect( client->session, username, password, resource, connect_timeout );
77 }
78
79 int client_disconnect( transport_client* client ) {
80         if( client == NULL ) { return 0; }
81         return session_disconnect( client->session );
82 }
83
84 int client_connected( transport_client* client ) {
85         if(client == NULL) return 0;
86         return client->session->state_machine->connected;
87 }
88
89 int client_send_message( transport_client* client, transport_message* msg ) {
90         if(client == NULL) return 0;
91         return session_send_msg( client->session, msg );
92 }
93
94
95 transport_message* client_recv( transport_client* client, int timeout ) {
96         if( client == NULL ) { return NULL; }
97
98         transport_message_node* node;
99         transport_message* msg;
100
101
102         /* see if there are any message in the messages queue */
103         if( client->m_list->next != NULL ) {
104                 /* pop off the first one... */
105                 node = client->m_list->next;
106                 client->m_list->next = node->next;
107                 msg = node->message;
108                 free( node );
109                 return msg;
110         }
111
112         if( timeout == -1 ) {  /* wait potentially forever for data to arrive */
113
114                 while( client->m_list->next == NULL ) {
115                         if( ! session_wait( client->session, -1 ) ) {
116                                 return NULL;
117                         }
118                 }
119
120         } else { /* wait at most timeout seconds */
121
122         
123                 /* if not, loop up to 'timeout' seconds waiting for data to arrive */
124                 time_t start = time(NULL);      
125                 time_t remaining = (time_t) timeout;
126
127                 int counter = 0;
128
129                 int wait_ret;
130                 while( client->m_list->next == NULL && remaining >= 0 ) {
131
132                         if( ! (wait_ret= session_wait( client->session, remaining)) ) 
133                                 return NULL;
134
135                         ++counter;
136
137 #ifdef _ROUTER
138                         // session_wait returns -1 if there is no more data and we're a router
139                         if( remaining == 0 && wait_ret == -1 ) {
140                                 break;
141                         }
142 #else
143                         if( remaining == 0 ) // or infinite loop
144                                 break;
145 #endif
146
147                         remaining -= (int) (time(NULL) - start);
148                 }
149
150                 info_handler("It took %d reads to grab this messag", counter);
151         }
152
153         /* again, see if there are any messages in the message queue */
154         if( client->m_list->next != NULL ) {
155                 /* pop off the first one... */
156                 node = client->m_list->next;
157                 client->m_list->next = node->next;
158                 msg = node->message;
159                 free( node );
160                 return msg;
161         } else {
162                 return NULL;
163         }
164 }
165
166 /* throw the message into the message queue */
167 void client_message_handler( void* client, transport_message* msg ){
168
169         if(client == NULL) return;
170         if(msg == NULL) return; 
171
172         transport_client* cli = (transport_client*) client;
173
174         size_t len = sizeof(transport_message_node);
175         transport_message_node* node = 
176                 (transport_message_node*) safe_malloc(len);
177         node->type = MESSAGE_LIST_ITEM;
178         node->message = msg;
179
180
181         /* find the last node and put this onto the end */
182         transport_message_node* tail = cli->m_list;
183         transport_message_node* current = tail->next;
184
185         while( current != NULL ) {
186                 tail = current;
187                 current = current->next;
188         }
189         tail->next = node;
190 }
191
192
193 int client_free( transport_client* client ){
194         if(client == NULL) return 0; 
195
196         session_free( client->session );
197         transport_message_node* current = client->m_list->next;
198         transport_message_node* next;
199
200         /* deallocate the list of messages */
201         while( current != NULL ) {
202                 next = current->next;
203                 message_free( current->message );
204                 free(current);
205                 current = next;
206         }
207
208         free( client->m_list );
209         free( client );
210         return 1;
211 }
212