Ignore:
Timestamp:
Jul 18, 2015, 5:06:52 PM (6 years ago)
Author:
katerina
Message:

Enhancements and fixes for tickets #374, #375, #376, #377, #378, and #379.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/sh_err_console.c

    r474 r481  
    2525#include "sh_error.h"
    2626#include "sh_utils.h"
     27#include "sh_sem.h"
    2728
    2829#undef  FIL__
     
    3637
    3738extern int  OnlyStderr;
    38 
    3939 
    4040#if !defined(O_NONBLOCK)
     
    5353#include <sys/msg.h>
    5454
     55#if !defined(EIDRM)
     56#define EIDRM (EINVAL)
     57#endif
     58
    5559struct sh_msgbuf {
    5660  long mtype;
     
    6670/* Open the SysV message queue, creating it when neccesary
    6771 */
    68 static int open_ipc(void)
     72static int open_queue(void)
    6973{
    7074  key_t            key;
    7175#if defined(WITH_TPT)
    72   int              error = 0;
    7376  char errbuf[SH_ERRBUF_SIZE];
    7477#endif
    7578
    76   SL_ENTER(_("open_ipc"));
     79  SL_ENTER(_("open_queue"));
    7780
    7881  /* get key
    7982   */
    80   key = ftok ("/tmp", '#');
     83  key = ftok (DEFAULT_DATAROOT, '#');
     84
    8185  if (key == (key_t) -1)
    8286    {
    83 #if defined(WITH_TPT)
    84       error = errno;
    85 #endif
    8687      TPT(( 0, FIL__, __LINE__, _("msg=<ftok: %s> errno=<%d>\n"),
    87             sh_error_message(error, errbuf, sizeof(errbuf)), error));
    88       SL_RETURN(-1, _("open_ipc"));
     88            sh_error_message(errno, errbuf, sizeof(errbuf)), errno));
     89      SL_RETURN(-1, _("open_queue"));
    8990    }
    9091
     
    9596  if (msgid < 0)
    9697    {
    97 #if defined(WITH_TPT)
    98       error = errno;
    99 #endif
    10098      TPT(( 0, FIL__, __LINE__, _("msg=<msgget: %s> errno=<%d>\n"),
    101             sh_error_message(error, errbuf, sizeof(errbuf)), error));
    102       SL_RETURN(-1, _("open_ipc"));
    103     }
    104 
    105   SL_RETURN(0, _("open_ipc"));
    106 }
    107 
    108 /* Close the SysV message queue
     99            sh_error_message(errno, errbuf, sizeof(errbuf)), errno));
     100      SL_RETURN(-1, _("open_queue"));
     101    }
     102
     103  SL_RETURN(0, _("open_queue"));
     104}
     105
     106/* Close the SysV message queue and/or semaphore
    109107 */
    110108void close_ipc (void)
    111109{
    112   SL_ENTER(_("close_ipc"));
    113 
    114110  if (msgid != (-1))
    115111    (void) msgctl (msgid, IPC_RMID, NULL);
    116   SL_RET0(_("close_ipc"));
     112  sh_sem_close();
     113  return;
    117114}
    118115
     
    128125}
    129126
    130 /* #define MY_MAX_MSG    254 */
    131127#define MY_MAX_MSG    1022
     128
     129static void remove_message()
     130{
     131  int rc;
     132  struct {
     133    long    mtype;       /* Message type. */
     134    char    mtext[128];  /* Message text. */
     135  } recv_msg;
     136
     137  recv_msg.mtype = 1;
     138  do {
     139    rc = msgrcv(msgid, &recv_msg, sizeof(recv_msg.mtext), 1,
     140                MSG_NOERROR|IPC_NOWAIT);
     141  } while (rc < 0 && errno == EINTR);
     142
     143  memset(&recv_msg, '\0', sizeof(recv_msg));
     144  return;
     145}
    132146
    133147static int push_message_queue (const char * msg)
     
    138152  int              count    = 0;
    139153#if defined(WITH_TPT)
    140   int              error = 0;
    141154  char errbuf[SH_ERRBUF_SIZE];
    142155#endif
     
    153166    {
    154167      TPT(( 0, FIL__, __LINE__, _("msg=<msg_queue not open>\n")));
    155       status = open_ipc();
     168      status = open_queue();
    156169    }
    157170
    158171  if (status < 0)
    159172    {
    160       TPT(( 0, FIL__, __LINE__, _("msg=<open_ipc() failed>\n")));
     173      TPT(( 0, FIL__, __LINE__, _("msg=<open_queue() failed>\n")));
    161174      SL_RETURN(-1, _("push_message_queue"));
    162175    }
     
    165178   *   long mtype;
    166179   *   char mtext[1];  <-- sizeof(mtext) will be  1+MY_MAX_MSG
    167    * }
    168    */
     180   * } */
     181
    169182  recv_msg = (struct sh_msgbuf*) SH_ALLOC(sizeof(struct sh_msgbuf)+MY_MAX_MSG);
    170183  recv_msg->mtype = 1;
     
    177190  if (count > 1)
    178191    {
     192      memset(recv_msg, '\0', MY_MAX_MSG+1);
    179193      SH_FREE(recv_msg);
    180194      SL_RETURN(-1, _("push_message_queue"));
    181195    }
    182196
    183   /* send the message
    184    */
    185   do {
    186     errno = 0;
     197  do { errno = 0;
    187198    rc = msgsnd(msgid, recv_msg, strlen(recv_msg->mtext)+1, IPC_NOWAIT);
    188   }
    189   while (rc < 0 && errno == EINTR);
     199
     200    if (rc == -1 && errno == EAGAIN)
     201      remove_message();
     202  } while (rc < 0 && (errno == EINTR && errno == EAGAIN));
    190203 
    191204  if (rc == -1 && errno != EAGAIN)
    192205    {
    193       /* EIDRM is not in OpenBSD
    194        */
    195       if (errno == EINVAL
    196 #if defined(EIDRM)
    197           || errno == EIDRM
    198 #endif
    199           )
    200         {
    201           TPT(( 0, FIL__, __LINE__, _("msg=<msg_queue not open>\n")));
    202           status = open_ipc();
    203           if (status == 0)
    204             {
    205               ++count;
    206               goto send_it;
    207             }
    208         }
    209       else
    210         {
    211 #if defined(WITH_TPT)
    212           error = errno;
    213 #endif
    214           TPT(( 0, FIL__, __LINE__, _("msg=<msgsnd: %s> errno=<%d>\n"),
    215                 sh_error_message(error, errbuf, sizeof(errbuf)), error));
    216           SH_FREE(recv_msg);
    217           SL_RETURN(-1, _("push_message_queue"));
    218         }
    219     }
    220 
     206      /* EIDRM is not in OpenBSD */
     207      if (errno == EINVAL || errno == EIDRM) {
     208        TPT(( 0, FIL__, __LINE__, _("msg=<msg_queue not open>\n")));
     209        status = open_queue();
     210        if (status == 0) {
     211          ++count;
     212          goto send_it; }
     213      } else {
     214        TPT(( 0, FIL__, __LINE__, _("msg=<msgsnd: %s> errno=<%d>\n"),
     215              sh_error_message(errno, errbuf, sizeof(errbuf)), errno));
     216        memset(recv_msg, '\0', MY_MAX_MSG+1);
     217        SH_FREE(recv_msg);
     218        SL_RETURN(-1, _("push_message_queue"));
     219      }
     220    }
     221
     222  memset(recv_msg, '\0', MY_MAX_MSG+1);
    221223  SH_FREE(recv_msg);
     224
    222225  SL_RETURN(0, _("push_message_queue"));
    223226}
     
    234237#endif
    235238
     239#else /* no message queue */
     240
     241void close_ipc() { sh_sem_close(); return; }
     242
    236243#endif
    237244
     
    283290  static int service_failure[2] = { 0, 0};
    284291  int    fd[2] = { -1, -1};
    285   int    sflags;
    286292  int    cc;
    287293  size_t len;
     
    331337    {
    332338      fd[0] = open ( sh.srvcons.name, O_WRONLY|O_APPEND|O_NOCTTY|O_NONBLOCK);
    333       if (fd[0] >= 0) {
    334         sflags = (int) retry_fcntl(FIL__, __LINE__, fd[0], F_GETFL, 0);
    335         if (sflags >= 0)
    336           {
    337             (void) retry_fcntl(FIL__, __LINE__, fd[0],
    338                                F_SETFL, sflags & ~O_NONBLOCK);
    339           }
    340       }
    341339
    342340      if (sh.srvcons.alt[0] != '\0')
    343341        {
    344342          fd[1] = open (sh.srvcons.alt, O_WRONLY|O_APPEND|O_NOCTTY|O_NONBLOCK);
    345           if (fd[1] >= 0) {
    346             sflags = (int) retry_fcntl(FIL__, __LINE__, fd[1], F_GETFL, 0);
    347             if (sflags >= 0)
    348               {
    349                 (void) retry_fcntl(FIL__, __LINE__, fd[1],
    350                                    F_SETFL, sflags & ~O_NONBLOCK);
    351               }
    352             ccMax = 2;
    353           }
     343          ccMax = 2;
    354344        }
    355345
Note: See TracChangeset for help on using the changeset viewer.