TSP: The Transport Sample Protocol



Main Page | Modules | Alphabetical List | Data Structures | File List | Data Fields | Globals | Related Pages

tsp_client.c

Go to the documentation of this file.
00001 
00038 #include "tsp_sys_headers.h"
00039 
00040 #include "tsp_client.h"
00041 
00042 #include "tsp_rpc.h"
00043 #include "tsp_rpc_confprogid.h"
00044 
00045 
00046 #define LOCAL_RPCCHECK_FALSE    if( server == (TSP_server_t)0)  \
00047                                 { STRACE_ERROR(("RPCCHECK failed")) ; return FALSE ;} 
00048                                 
00049 #define LOCAL_RPCCHECK_0        if( server == (TSP_server_t)0) \
00050                                 { STRACE_ERROR(("RPCCHECK failed")) ; return 0 ;} 
00051 
00052 TSP_provider_info_t * tsp_provider_information(TSP_server_t server)
00053 {
00054 
00055   TSP_provider_info_t* result;
00056         
00057   STRACE_IO(("-->IN"));
00058 
00059         
00060   LOCAL_RPCCHECK_0;
00061         
00062   result = tsp_provider_information_1(server);
00063   TSP_STRACE_RPC_ERROR(server, result);
00064         
00065   STRACE_IO(("-->OUT"));
00066 
00067         
00068   return result;
00069 }       
00070 
00071 CLIENT* tsp_remote_open_progid(const char *target_name, int progid)
00072 {
00073 
00074   CLIENT* cl = (CLIENT *)0;
00075   struct timeval timeout = { 1, 0 };
00076 
00077   STRACE_IO(("-->IN"));
00078 
00079   /*cl = clnt_create_timed(target_name, progid, TSP_RPC_VERSION_INITIAL, "tcp",&timeout );*/
00080 
00081   
00082 
00083   cl = clnt_create(target_name, progid, TSP_RPC_VERSION_INITIAL, "tcp");
00084 
00085   if(cl == (CLIENT *)0)
00086     {
00087       STRACE_DEBUG(("ERROR : GLOBAL clnt_create failed for host %s", target_name));
00088     }
00089   else
00090     {
00091       STRACE_INFO(("CONNECTED to server %s", target_name));
00092       /* Set time out */
00093       tsp_wrap_rpc_clnt_set_timeout(cl, TSP_RPC_CONNECT_TIMEOUT);
00094 
00095     }
00096  
00097    
00098 
00099   STRACE_IO(("-->OUT"));
00100 
00101   return cl;
00102         
00103 }
00104 
00105 int TSP_remote_open_server( const char *protocol,
00106                             const char *target_name,
00107                             const char *server_name,
00108                             const int server_id, 
00109                             TSP_server_t* server,
00110                             TSP_server_info_string_t server_info)
00111 {
00112 
00113   int prodid_max_number, progid;
00114   int ret = FALSE;
00115   TSP_provider_info_t* server_info_t;
00116         
00117   *server = (TSP_server_t)0;
00118   server_info[0] = '\0';
00119         
00120   STRACE_IO(("-->IN"));
00121 
00122   prodid_max_number = TSP_get_progid_total_number();
00123 
00124   if(strcmp(protocol, TSP_RPC_PROTOCOL) != 0)
00125     {
00126       STRACE_ERROR(("Protocol %s not handled, use %s", protocol, TSP_RPC_PROTOCOL));
00127     }
00128   else if((server_id < prodid_max_number) && (server_id >=0) )
00129     {
00130       progid = TSP_get_progid(server_id);
00131       if(progid > 0) 
00132         {
00133           *server = tsp_remote_open_progid(target_name, progid);
00134           if( (*server) != (TSP_server_t)0)
00135             {
00136               /*  On recupere la chaine d'info du serveur) */
00137               server_info_t = tsp_provider_information(*server);
00138               if( server_info_t != NULL)
00139                 {       
00140                   if( STRING_SIZE_SERVER_INFO >= strlen(server_info_t->info) )
00141                     {
00142                       /* check whether server name is the one requested */
00143                       if(strncmp(server_name,
00144                                  server_info_t->info,
00145                                  strlen(server_name)) == 0)
00146                         {
00147                           strcpy(server_info, server_info_t->info);
00148                           STRACE_INFO(("Server opened : '%s'", server_info));
00149                           ret = TRUE;
00150                         }
00151                       else
00152                         {
00153                           STRACE_INFO(("Not the requested server : '%s'", server_info_t->info));
00154                           TSP_remote_close_server(*server);
00155                           ret = FALSE;
00156                         }
00157                     }
00158                   else
00159                     {
00160                       STRACE_ERROR(("Returned info string too long"));
00161                     }
00162                 }
00163               else
00164                 {
00165                   STRACE_ERROR(("%s", clnt_sperror(*server, "sp_server_info_1\n") ));
00166                 }
00167               
00168             }
00169           else
00170             {
00171               STRACE_DEBUG(("tsp_remote_open_progid failed"));
00172             }
00173                         
00174         }
00175       else
00176         {
00177           STRACE_ERROR(("No ProgId for Server Id=%d", server_id));
00178         }
00179                 
00180     }
00181   else
00182     {
00183       STRACE_ERROR(("server_id %d too high", server_id));
00184     }
00185         
00186   STRACE_IO(("-->OUT"));
00187 
00188         
00189   return ret;
00190         
00191 }
00192 
00193 void TSP_remote_close_server(TSP_server_t server)
00194 {
00195   if(server)
00196     {
00197       clnt_destroy((CLIENT*)server);
00198     }
00199 }
00200 
00201 
00202 int TSP_get_server_max_number()
00203 {
00204   return TSP_get_progid_total_number();
00205 }
00206 
00207 TSP_answer_open_t * TSP_request_open(const TSP_request_open_t* req_open, TSP_server_t server)
00208 {
00209 
00210   TSP_answer_open_t* result;
00211         
00212   STRACE_IO(("-->IN"));
00213 
00214         
00215   LOCAL_RPCCHECK_0;
00216         
00217   result = tsp_request_open_1(*req_open, server);
00218   TSP_STRACE_RPC_ERROR(server, result);
00219         
00220   STRACE_IO(("-->OUT"));
00221 
00222         
00223   return result;
00224 }       
00225 
00226 int TSP_request_close(const TSP_request_close_t* req_close, TSP_server_t server)
00227 {
00228 
00229   int result;
00230         
00231   STRACE_IO(("-->IN"));
00232         
00233   LOCAL_RPCCHECK_FALSE;
00234     
00235   result = (int)tsp_request_close_1(*req_close, server);
00236   TSP_STRACE_RPC_ERROR(server, result);
00237   
00238   STRACE_IO(("-->OUT"));
00239         
00240   return result;
00241 }       
00242 
00243 TSP_answer_sample_t * TSP_request_information(const TSP_request_information_t* req_info, TSP_server_t server)
00244 {
00245 
00246   TSP_answer_sample_t* result;
00247         
00248   STRACE_IO(("-->IN"));
00249 
00250         
00251   LOCAL_RPCCHECK_0;
00252         
00253   result = tsp_request_information_1(*req_info, server);
00254   TSP_STRACE_RPC_ERROR(server, result);
00255   
00256   STRACE_IO(("-->OUT"));
00257         
00258   return result;
00259 }       
00260 
00261 TSP_answer_sample_t * TSP_request_sample(
00262                                          const TSP_request_sample_t* req_sample,
00263                                          TSP_server_t server)
00264 {
00265 
00266   TSP_answer_sample_t* result;
00267         
00268   STRACE_IO(("-->IN"));
00269 
00270         
00271   LOCAL_RPCCHECK_0;
00272         
00273   result = tsp_request_sample_1(*req_sample, server);
00274   TSP_STRACE_RPC_ERROR(server, result);
00275         
00276   STRACE_IO(("-->OUT"));
00277 
00278         
00279   return result;
00280 }
00281 
00282 TSP_answer_sample_init_t * TSP_request_sample_init(
00283                                               const TSP_request_sample_init_t* req_sample,
00284                                               TSP_server_t server)
00285 {
00286 
00287   TSP_answer_sample_init_t* result;
00288         
00289   STRACE_IO(("-->IN"));
00290 
00291         
00292   LOCAL_RPCCHECK_0;
00293         
00294   result = tsp_request_sample_init_1(*req_sample, server);
00295   TSP_STRACE_RPC_ERROR(server, result);
00296         
00297   STRACE_IO(("-->OUT"));
00298 
00299         
00300   return result;
00301 }
00302 
00303 TSP_answer_sample_destroy_t*
00304 TSP_request_sample_destroy(const TSP_request_sample_destroy_t* req_sample,
00305                            TSP_server_t server)
00306 {
00307   
00308   TSP_answer_sample_destroy_t* result;
00309         
00310   STRACE_IO(("-->IN"));
00311         
00312   LOCAL_RPCCHECK_0;
00313         
00314   result = tsp_request_sample_destroy_1(*req_sample, server);
00315   TSP_STRACE_RPC_ERROR(server, result);
00316         
00317   STRACE_IO(("-->OUT"));
00318         
00319   return result;
00320 }
00321 
00322         
Framework Home Page.

Beware !! TSP wave is coming...