src/libtransport/transport_client.c

   1 #include "opensrf/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, int component ) {
  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, component );
  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         }
 151
 152         /* again, see if there are any messages in the message queue */
 153         if( client->m_list->next != NULL ) {
 154                 /* pop off the first one... */
 155                 node = client->m_list->next;
 156                 client->m_list->next = node->next;
 157                 msg = node->message;
 158                 free( node );
 159                 return msg;
 160         } else {
 161                 return NULL;
 162         }
 163 }
 164
 165 /* throw the message into the message queue */
 166 void client_message_handler( void* client, transport_message* msg ){
 167
 168         if(client == NULL) return;
 169         if(msg == NULL) return;
 170
 171         transport_client* cli = (transport_client*) client;
 172
 173         size_t len = sizeof(transport_message_node);
 174         transport_message_node* node =
 175                 (transport_message_node*) safe_malloc(len);
 176         node->type = MESSAGE_LIST_ITEM;
 177         node->message = msg;
 178
 179
 180         /* find the last node and put this onto the end */
 181         transport_message_node* tail = cli->m_list;
 182         transport_message_node* current = tail->next;
 183
 184         while( current != NULL ) {
 185                 tail = current;
 186                 current = current->next;
 187         }
 188         tail->next = node;
 189 }
 190
 191
 192 int client_free( transport_client* client ){
 193         if(client == NULL) return 0;
 194
 195         session_free( client->session );
 196         transport_message_node* current = client->m_list->next;
 197         transport_message_node* next;
 198
 199         /* deallocate the list of messages */
 200         while( current != NULL ) {
 201                 next = current->next;
 202                 message_free( current->message );
 203                 free(current);
 204                 current = next;
 205         }
 206
 207         free( client->m_list );
 208         free( client );
 209         return 1;
 210 }
 211