tty_srv.cc Source File

00001 /****************************************************************************
00002 * File: tty_srv.cc
00003 * Purpose: Provides the functions for the class CMS_SERVER_REMOTE_T_PORT
00004 *  which provides TTY specific overrides of the CMS_SERVER_REMOTE_PORT class.
00005 ****************************************************************************/
00006 
00007 #include "rcs_defs.hh"          /* EXTERN_C_STD_HEADERS */
00008 #include "sokintrf.h"           /* dl_ioctl() */
00009 #include "ttyintf.hh"
00010 
00011 #ifdef EXTERN_C_STD_HEADERS
00012 extern "C"
00013 {
00014 #endif
00015 
00016 #include <string.h>             /* memset(), strerror() */
00017 #include <stdlib.h>             // malloc(), free()
00018 
00019 #ifndef UNDER_CE
00020 #include <errno.h>              /* errno */
00021 #include <signal.h>             // SIGPIPE, signal()
00022 #endif
00023 
00024 #if (defined(__CENTERLINE__) && !defined(VXWORKS)) || defined(sunos5) || defined(sparcworks)
00025 #include <sys/filio.h>          /* FIONREAD */
00026   char *strerror (int errnum);
00027   char *dl_inet_ntoa (struct in_addr);
00028 #endif
00029 
00030 #ifdef EXTERN_C_STD_HEADERS
00031 }
00032 #endif
00033 
00034 #include "cms.hh"               /* class CMS */
00035 #include "nml.hh"               // class NML
00036 #include "tty_srv.hh"           /* class CMS_SERVER_REMOTE_TTY_PORT */
00037 #include "rcs_prnt.hh"          /* rcs_print_error() */
00038 #include "linklist.hh"          /* class RCS_LINKED_LIST */
00039 #include "timer.hh"             // esleep()
00040 
00041 
00042 CMS_SERVER_REMOTE_TTY_PORT::CMS_SERVER_REMOTE_TTY_PORT (CMS_SERVER *
00043                                                         _cms_server):CMS_SERVER_REMOTE_PORT
00044   (_cms_server)
00045 {
00046   handle = (RCS_SERIAL_PORT_HANDLE) - 1;
00047   memset (devName, 0, 0x100);
00048 }
00049 
00050 CMS_SERVER_REMOTE_TTY_PORT::~CMS_SERVER_REMOTE_TTY_PORT ()
00051 {
00052   unregister_port ();
00053 }
00054 
00055 void
00056 CMS_SERVER_REMOTE_TTY_PORT::unregister_port ()
00057 {
00058   close_serial_communications_port (handle);
00059 }
00060 
00061 int
00062 CMS_SERVER_REMOTE_TTY_PORT::accept_local_port_cms (CMS * _cms)
00063 {
00064   if (NULL == _cms)
00065     {
00066       return 0;
00067     }
00068   if (_cms->remote_port_type != CMS_TTY_REMOTE_PORT_TYPE)
00069     {
00070       return 0;
00071     }
00072   if (NULL != _cms)
00073     {
00074 #ifdef UNIX_LIKE_PLAT
00075       char *default_dev_name = "/dev/ttyb";
00076 #else
00077       char *default_dev_name = "COM2:";
00078 #endif
00079       char ttyDevName[80];
00080       char *devNameEq = strstr (_cms->ProcessLine, "serialPortDevName=");
00081       if (NULL != devNameEq)
00082         {
00083           strncpy (ttyDevName, devNameEq + 18, 80);
00084         }
00085       else
00086         {
00087           strncpy (ttyDevName, default_dev_name, 80);
00088         }
00089       if (devName[0] == 0)
00090         {
00091           strncpy (devName, clean_string (ttyDevName, 80), 80);
00092           settings.baud_rate = 9600;
00093           settings.data_bits = 8;
00094           settings.stop_bits = 1;
00095           settings.use_parity = 0;
00096 
00097           if (strstr (_cms->BufferLine, "evenparity"))
00098             {
00099               settings.use_parity = 1;
00100               settings.even_parity = 1;
00101             }
00102           if (strstr (_cms->BufferLine, "oddparity"))
00103             {
00104               settings.use_parity = 1;
00105               settings.even_parity = 0;
00106             }
00107 
00108           char *baud_rate_eq = strstr (_cms->BufferLine, "baud_rate=");
00109           if (NULL != baud_rate_eq)
00110             {
00111               settings.baud_rate = atol (baud_rate_eq + 10);
00112             }
00113           char *data_bits_eq = strstr (_cms->BufferLine, "data_bits=");
00114           if (NULL != data_bits_eq)
00115             {
00116               settings.data_bits = atol (data_bits_eq + 10);
00117             }
00118           char *stop_bits_eq = strstr (_cms->BufferLine, "stop_bits=");
00119           if (NULL != stop_bits_eq)
00120             {
00121               settings.stop_bits = atol (stop_bits_eq + 10);
00122             }
00123           return 1;
00124         }
00125       else
00126         {
00127           if (!strcmp (devName, ttyDevName))
00128             {
00129               return 1;
00130             }
00131         }
00132     }
00133   return 0;
00134 }
00135 
00136 void
00137 CMS_SERVER_REMOTE_TTY_PORT::register_port ()
00138 {
00139 
00140   handle = open_serial_communications_port (devName);
00141   if (handle < 0)
00142     {
00143       return;
00144     }
00145   if (set_serial_port_configuration (handle, &settings) < 0)
00146     {
00147       return;
00148     }
00149   port_registered = 1;
00150 }
00151 
00152 
00153 void
00154 CMS_SERVER_REMOTE_TTY_PORT::run ()
00155 {
00156   cms_server_count++;
00157   while (1)
00158     {
00159       if (readn_serial_communications_port (handle, temp_buffer, 20) < 20)
00160         {
00161           rcs_print_error ("Can not read from serial port.\n");
00162         }
00163       handle_request ();
00164     }
00165 }
00166 
00167 
00168 void
00169 CMS_SERVER_REMOTE_TTY_PORT::handle_request ()
00170 {
00171 
00172 #if defined(WIN32) && !defined(gnuwin32)
00173   DWORD pid = GetCurrentProcessId ();
00174   DWORD tid = GetCurrentThreadId ();
00175 #else
00176 #ifdef VXWORKS
00177   int pid = taskIdSelf ();
00178 
00179   int tid = 0;
00180 #else
00181   pid_t pid = getpid ();
00182   pid_t tid = 0;
00183 #endif
00184 #endif
00185 
00186   CMS_SERVER *server;
00187   server = find_server (pid, tid);
00188   if (NULL == server)
00189     {
00190       rcs_print_error
00191         ("CMS_SERVER_REMOTE_TTY_PORT::handle_request() Cannot find server object for pid = %d.\n",
00192          pid);
00193       return;
00194     }
00195 
00196   u_long request_type, buffer_number, received_serial_number;
00197   received_serial_number = dl_ntohl (*((u_long *) temp_buffer));
00198   request_type = dl_ntohl (*((u_long *) temp_buffer + 1));
00199   buffer_number = dl_ntohl (*((u_long *) temp_buffer + 2));
00200   serial_number = received_serial_number;
00201   serial_number++;
00202 
00203   int total_subdivisions = 1;
00204 
00205   switch (request_type)
00206     {
00207     case REMOTE_CMS_GET_BUF_NAME_REQUEST_TYPE:
00208       {
00209         REMOTE_GET_BUF_NAME_REQUEST namereq;
00210         namereq.buffer_number = buffer_number;
00211         REMOTE_GET_BUF_NAME_REPLY *namereply = NULL;
00212         namereply =
00213           (REMOTE_GET_BUF_NAME_REPLY *) server->process_request (&namereq);
00214         memset (temp_buffer, 0, 40);
00215         if (NULL != namereply)
00216           {
00217             *((u_long *) temp_buffer) = dl_htonl (serial_number);
00218             *((u_long *) temp_buffer + 1) = dl_htonl (namereply->status);
00219             strncpy (temp_buffer + 8, namereply->name, 31);
00220             if (write_serial_communications_port (handle, temp_buffer, 40) <
00221                 0)
00222               {
00223                 return;
00224               }
00225           }
00226         else
00227           {
00228             *((u_long *) temp_buffer) = dl_htonl (serial_number);
00229             *((u_long *) temp_buffer + 1) =
00230               dl_htonl ((unsigned long) CMS_SERVER_SIDE_ERROR);
00231             if (write_serial_communications_port (handle, temp_buffer, 40) <
00232                 0)
00233               {
00234                 return;
00235               }
00236           }
00237       }
00238       break;
00239 
00240 
00241     case REMOTE_CMS_READ_REQUEST_TYPE:
00242       server->read_req.buffer_number = buffer_number;
00243       server->read_req.access_type = dl_ntohl (*((u_long *) temp_buffer + 3));
00244       server->read_req.last_id_read =
00245         dl_ntohl (*((u_long *) temp_buffer + 4));
00246       server->read_reply =
00247         (REMOTE_READ_REPLY *) server->process_request (&server->read_req);
00248       if (max_total_subdivisions > 1)
00249         {
00250           total_subdivisions = server->get_total_subdivisions (buffer_number);
00251         }
00252       if (total_subdivisions > 1)
00253         {
00254           if (readn_serial_communications_port
00255               (handle, (char *) (((u_long *) temp_buffer) + 5), 4) < 0)
00256             {
00257               rcs_print_error ("Can not read from serial port\n");
00258               return;
00259             }
00260           server->read_req.subdiv = dl_ntohl (*((u_long *) temp_buffer + 5));
00261         }
00262       else
00263         {
00264           server->read_req.subdiv = 0;
00265         }
00266       if (NULL == server->read_reply)
00267         {
00268           rcs_print_error ("Server could not process request.\n");
00269           *((u_long *) temp_buffer) = dl_htonl (serial_number);
00270           *((u_long *) temp_buffer + 1) =
00271             dl_htonl ((unsigned long) CMS_SERVER_SIDE_ERROR);
00272           *((u_long *) temp_buffer + 2) = dl_htonl (0); /* size */
00273           *((u_long *) temp_buffer + 3) = dl_htonl (0); /* write_id */
00274           *((u_long *) temp_buffer + 4) = dl_htonl (0); /* was_read */
00275           write_serial_communications_port (handle, temp_buffer, 20);
00276           return;
00277         }
00278       *((u_long *) temp_buffer) = dl_htonl (serial_number);
00279       *((u_long *) temp_buffer + 1) = dl_htonl (server->read_reply->status);
00280       *((u_long *) temp_buffer + 2) = dl_htonl (server->read_reply->size);
00281       *((u_long *) temp_buffer + 3) = dl_htonl (server->read_reply->write_id);
00282       *((u_long *) temp_buffer + 4) = dl_htonl (server->read_reply->was_read);
00283       if (server->read_reply->size < (0x2000 - 20)
00284           && server->read_reply->size > 0)
00285         {
00286           memcpy (temp_buffer + 20, server->read_reply->data,
00287                   server->read_reply->size);
00288           if (write_serial_communications_port
00289               (handle, temp_buffer, 20 + server->read_reply->size) < 0)
00290             {
00291               return;
00292             }
00293         }
00294       else
00295         {
00296           if (write_serial_communications_port (handle, temp_buffer, 20) < 0)
00297             {
00298               return;
00299             }
00300           if (server->read_reply->size > 0)
00301             {
00302               if (write_serial_communications_port
00303                   (handle, (char *) server->read_reply->data,
00304                    server->read_reply->size) < 0)
00305                 {
00306                   return;
00307                 }
00308             }
00309         }
00310       break;
00311 
00312     case REMOTE_CMS_WRITE_REQUEST_TYPE:
00313       server->write_req.buffer_number = buffer_number;
00314       server->write_req.access_type =
00315         dl_ntohl (*((u_long *) temp_buffer + 3));
00316       server->write_req.size = dl_ntohl (*((u_long *) temp_buffer + 4));
00317       total_subdivisions = 1;
00318       if (max_total_subdivisions > 1)
00319         {
00320           total_subdivisions = server->get_total_subdivisions (buffer_number);
00321         }
00322       if (total_subdivisions > 1)
00323         {
00324           if (readn_serial_communications_port
00325               (handle, (char *) (((u_long *) temp_buffer) + 5), 4) < 0)
00326             {
00327               return;
00328             }
00329           server->write_req.subdiv = dl_ntohl (*((u_long *) temp_buffer + 5));
00330         }
00331       else
00332         {
00333           server->write_req.subdiv = 0;
00334         }
00335       if (server->write_req.size > 0)
00336         {
00337           if (readn_serial_communications_port
00338               (handle, (char *) server->write_req.data,
00339                server->write_req.size) < 0)
00340             {
00341               return;
00342             }
00343         }
00344       server->write_reply =
00345         (REMOTE_WRITE_REPLY *) server->process_request (&server->write_req);
00346       if (min_compatible_version < 2.58 && min_compatible_version > 1e-6
00347           || confirm_write)
00348         {
00349           if (NULL == server->write_reply)
00350             {
00351               rcs_print_error ("Server could not process request.\n");
00352               *((u_long *) temp_buffer) = dl_htonl (serial_number);
00353               *((u_long *) temp_buffer + 1) =
00354                 dl_htonl ((unsigned long) CMS_SERVER_SIDE_ERROR);
00355               *((u_long *) temp_buffer + 2) = dl_htonl (0);     /* was_read */
00356               write_serial_communications_port (handle, temp_buffer, 12);
00357               return;
00358             }
00359           *((u_long *) temp_buffer) = dl_htonl (serial_number);
00360           *((u_long *) temp_buffer + 1) =
00361             dl_htonl (server->write_reply->status);
00362           *((u_long *) temp_buffer + 2) =
00363             dl_htonl (server->write_reply->was_read);
00364           if (write_serial_communications_port (handle, temp_buffer, 12) < 0)
00365             {
00366             }
00367         }
00368       else
00369         {
00370           if (NULL == server->write_reply)
00371             {
00372               rcs_print_error ("Server could not process request.\n");
00373             }
00374         }
00375       break;
00376 
00377     case REMOTE_CMS_CHECK_IF_READ_REQUEST_TYPE:
00378       server->check_if_read_req.buffer_number = buffer_number;
00379       server->check_if_read_req.subdiv =
00380         dl_ntohl (*((u_long *) temp_buffer + 3));
00381       server->check_if_read_reply =
00382         (REMOTE_CHECK_IF_READ_REPLY *) server->process_request (&server->
00383                                                                 check_if_read_req);
00384       if (NULL == server->check_if_read_reply)
00385         {
00386           rcs_print_error ("Server could not process request.\n");
00387           *((u_long *) temp_buffer) = dl_htonl (serial_number);
00388           *((u_long *) temp_buffer + 1) =
00389             dl_htonl ((unsigned long) CMS_SERVER_SIDE_ERROR);
00390           *((u_long *) temp_buffer + 2) = dl_htonl (0); /* was_read */
00391           write_serial_communications_port (handle, temp_buffer, 12);
00392           return;
00393         }
00394       *((u_long *) temp_buffer) = dl_htonl (serial_number);
00395       *((u_long *) temp_buffer + 1) =
00396         dl_htonl (server->check_if_read_reply->status);
00397       *((u_long *) temp_buffer + 2) =
00398         dl_htonl (server->check_if_read_reply->was_read);
00399       if (write_serial_communications_port (handle, temp_buffer, 12) < 0)
00400         {
00401         }
00402       break;
00403 
00404     case REMOTE_CMS_CLEAR_REQUEST_TYPE:
00405       server->clear_req.buffer_number = buffer_number;
00406       server->clear_req.subdiv = dl_ntohl (*((u_long *) temp_buffer + 3));
00407       server->clear_reply =
00408         (REMOTE_CLEAR_REPLY *) server->process_request (&server->clear_req);
00409       if (NULL == server->clear_reply)
00410         {
00411           rcs_print_error ("Server could not process request.\n");
00412           *((u_long *) temp_buffer) = dl_htonl (serial_number);
00413           *((u_long *) temp_buffer + 1) =
00414             dl_htonl ((u_long) CMS_SERVER_SIDE_ERROR);
00415           write_serial_communications_port (handle, temp_buffer, 8);
00416           return;
00417         }
00418       *((u_long *) temp_buffer) = dl_htonl (serial_number);
00419       *((u_long *) temp_buffer + 1) = dl_htonl (server->clear_reply->status);
00420       if (write_serial_communications_port (handle, temp_buffer, 8) < 0)
00421         {
00422         }
00423       break;
00424 
00425     default:
00426       rcs_print_error ("Unrecognized request type received.(%ld)\n",
00427                        request_type);
00428       break;
00429     }
00430 }