Changeset 383


Ignore:
Timestamp:
Dec 5, 2011, 10:30:33 PM (9 years ago)
Author:
katerina
Message:

Fix for ticket #281 (warnings from clang static analyzer).

Location:
trunk
Files:
30 edited

Legend:

Unmodified
Added
Removed
  • trunk/configure.ac

    r378 r383  
    1212dnl start
    1313dnl
    14 AM_INIT_AUTOMAKE(samhain, 3.0.0a)
     14AM_INIT_AUTOMAKE(samhain, 3.0.1)
    1515AC_DEFINE([SAMHAIN], 1, [Application is samhain])
    1616AC_CANONICAL_HOST
  • trunk/include/sh_mem.h

    r149 r383  
    3535#define SH_FREE(a)   sh_mem_free((a), FIL__, __LINE__)
    3636#define SH_ALLOC(a)  sh_mem_malloc((a), FIL__, __LINE__)
     37#define SH_OALLOC(a,b,c)  sh_mem_malloc((a), (b), (c))
    3738
    3839#else
     
    5152#define SH_FREE(a)   sh_mem_free(a)
    5253#define SH_ALLOC(a)  sh_mem_malloc(a)
     54#define SH_OALLOC(a,b,c)  ((void) (b),           \
     55                           (void) (c),           \
     56                           sh_mem_malloc(a))     \
    5357
    5458#endif
  • trunk/include/sh_pthread.h

    r378 r383  
    3131        do {                                                               \
    3232                int oldtype;                                               \
    33                 int executeStack = 0;                                      \
     33                volatile int executeStack = 0;                             \
    3434                pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &oldtype);  \
    3535                pthread_cleanup_push(sh_pthread_mutex_unlock, (void*)&(M));\
  • trunk/src/depend-gen.c

    r1 r383  
    197197  p = strrchr(name, '/');
    198198  if (p)
    199     ++p;
    200   len = strlen(p);
     199    {
     200      ++p;
     201      len = strlen(p);
     202    }
    201203
    202204  /* skip other dependencies
     
    206208      if (NULL == fgets(line, 1023, fout))
    207209        break;
    208       if (0 == strncmp(line, p, len))
     210      if (p && 0 == strncmp(line, p, len))
    209211        break;
    210212      fprintf(ftmp, "%s", line);
  • trunk/src/dnmalloc.c

    r362 r383  
    28542854      assert(temp != NULL);
    28552855#endif
    2856       prevtemp->hash_next = temp->hash_next;
     2856      if (temp) prevtemp->hash_next = temp->hash_next;
    28572857    }
    28582858}
     
    35583558   
    35593559    else {
    3560       front_misalign = 0;
    3561       end_misalign = 0;
     3560      /* front_misalign = 0; *//*superfluous */
     3561      /* end_misalign = 0; *//*superfluous */
    35623562      correction = 0;
    35633563      aligned_brk = brk;
     
    42844284  retval = sYSMALLOc(nb, av);
    42854285  if (retval) {
    4286     victim = mem2chunk(retval);
     4286#if PARANOIA > 2
     4287    victim = mem2chunk(retval); /* is used in guard_set macro */
     4288#endif
    42874289    guard_set(av->guard_stored, victim, bytes, nb);
    42884290  }
     
    55165518        } rdat;
    55175519#if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__)
    5518         size_t sz = 0;
     5520        ssize_t sz = 0;
    55195521        int    fd;
    55205522#endif
     
    55405542        fd = open("/dev/urandom", O_RDONLY);
    55415543        if (fd != -1) {
    5542                 sz = (size_t)read(fd, rdat.rnd, sizeof (rdat.rnd));
    5543                 close(fd);
     5544                sz = (size_t)read(fd, rdat.rnd, sizeof (rdat.rnd));
     5545                /*
     5546                 * gcc complains if we ignore the return value of read(), and
     5547                 * the llvm/clang analyzer complains if we don't use it...
     5548                 */
     5549                if (sz > (-256)) /* always true */
     5550                  close(fd);
    55445551        }
     5552        /*
    55455553        if (sz > sizeof (rdat.rnd))
    55465554                sz = 0;
     5555        */
    55475556 #endif
    55485557
  • trunk/src/rijndael-alg-fst.c

    r291 r383  
    2828         */
    2929        int j, r, t, rconpointer = 0;
    30         word8 tk[MAXKC][4];
     30        word8 tk[MAXKC][4] = { { 0 } }; /* init for llvm/clang analyzer */
    3131        int KC = ROUNDS - 6;
    3232        word32 tmp;
  • trunk/src/sh_error.c

    r352 r383  
    648648    }
    649649
     650  if (!str_s)
     651    {
     652      SL_RETURN ((-1), _("sh_error_set_level"));
     653    }
    650654  /* skip to end of string
    651655   */
  • trunk/src/sh_extern.c

    r321 r383  
    435435                  /* failed
    436436                   */
    437                   _exit(EXIT_FAILURE);
     437                  _exit((errnum == 0) ? (EXIT_SUCCESS) : (EXIT_FAILURE));
    438438              }
    439439              PDBGC_S("fexecve: not working");
     
    471471          /* failed
    472472           */
    473           _exit(EXIT_FAILURE);
     473          _exit((errnum == 0) ? (EXIT_SUCCESS) : (EXIT_FAILURE));
    474474        }
    475475      /*
  • trunk/src/sh_files.c

    r381 r383  
    107107  po = SH_ALLOC(len+1); *po = '\0'; p = po; pend = &po[len];
    108108
    109   i = 0; q = s;
     109  q = s;
    110110
    111111  do
     
    925925#endif
    926926
    927 int sh_files_push_file_int (int class, const char * str_s, size_t len, unsigned long check_mask)
     927int sh_files_push_file_int (int class, const char * str_s, size_t len,
     928                            unsigned long check_mask)
    928929{
    929930  dirstack_t * new_item_ptr;
    930931  char  * fileName;
    931932  int     ret;
    932   int     count = 0;
     933  volatile int     count = 0;
    933934
    934935  SL_ENTER(_("sh_files_push_file_int"));
     
    10221023  glob_t  pglob;
    10231024
    1024   int     count = 0;
     1025  volatile int     count = 0;
    10251026  volatile unsigned long check_mask = (flag == 0) ? sh_files_maskof(class) : check_mask_in;
    10261027 
     
    18771878
    18781879static void * sh_dummy_dirlist;
     1880static void * sh_dummy_tmpcat;
    18791881
    18801882/* -- Check a single directory and its content. Does not
     
    19041906  int             class  = 0;
    19051907  volatile int    rdepth_next;
    1906   int             class_next;
     1908  volatile int    class_next;
    19071909  volatile int    file_class_next;
    1908   unsigned long   check_mask_next;
     1910  volatile unsigned long   check_mask_next;
    19091911  volatile unsigned long   file_check_mask_next;
    19101912
     
    19211923
    19221924  SL_ENTER(_("sh_files_checkdir"));
    1923 
    1924   sh_dummy_dirlist = (void *) &dirlist;
    19251925
    19261926  if (sig_urgent > 0) {
     
    20642064  sl_strlcpy (theDir->DirPath, iname, PATH_MAX);
    20652065
     2066
     2067  sh_dummy_dirlist = (void *) &dirlist;
     2068  sh_dummy_tmpcat  = (void *) &tmpcat;
    20662069
    20672070  /* ---- read ----
     
    23472350      {
    23482351        SH_FREE(theDir);
     2352        sh_dummy_dirlist = NULL;
    23492353        SL_RETURN((0), _("sh_files_checkdir"));
    23502354      }
     
    23972401  SH_FREE(tmpname);
    23982402  SH_FREE(theDir);
     2403
     2404  sh_dummy_dirlist = NULL;
    23992405
    24002406  SL_RETURN((0), _("sh_files_checkdir"));
     
    26862692                        int * rdepth)
    26872693{
    2688   int retval = 0;
     2694  volatile int retval = 0;
    26892695#if defined(HAVE_GLOB_H) && defined(HAVE_FNMATCH_H)
    26902696  sh_globstack_t * testPattern;
     
    27572763                         unsigned long *check_mask, int *reported)
    27582764{
    2759   int retval = 0;
     2765  volatile int retval = 0;
    27602766#if defined(HAVE_GLOB_H) && defined(HAVE_FNMATCH_H)
    27612767  sh_globstack_t * testPattern;
  • trunk/src/sh_forward.c

    r379 r383  
    455455                            _("sh_forward_send_intern: blockEncrypt"));
    456456          memcpy(q, outBlock, B_SIZ);
    457           q += B_SIZ;
     457          /* q += B_SIZ; *//* never read */
    458458        }
    459459
     
    584584    }
    585585  /*@-usedef +ignoresigns@*/
     586  else if (msgbuf == NULL)
     587    {
     588      sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_SUBGEN,
     589                      _("msgbuf is NULL"), _("sh_forward_receive_intern"));
     590      SL_RETURN((-1), _("sh_forward_receive_intern"));
     591    }
    586592  else if (head[0] != protocol && 
    587593           (head[0] & SH_PROTO_SRP) == (char)0 /* not set */)
     
    16661672            {
    16671673              flag_err = (-1);
    1668               sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_EFIL);
     1674              sh_error_handle((-1), FIL__, __LINE__, flag_err, MSG_TCP_EFIL);
    16691675            }
    16701676          else
     
    16731679               */
    16741680              transfercount = 0;
    1675               flag_err      = 0;
     1681              /* flag_err      = 0; *//* never read */
    16761682
    16771683              do {
     
    17341740              if (0 == check_request_nerr(head_u, _("EEOT")) &&
    17351741                  0 <  flag_err                             &&
    1736                   0 == hash_check (foo_M1, answer, (int)strlen(answer)))
     1742                  0 == hash_check (foo_M1, answer, (int)sl_strlen(answer)))
    17371743                {
    17381744                  flag_err =
     
    17451751                  (void) sl_sync(sfd);
    17461752                  if (flag_err_info == SL_TRUE)
    1747                     sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_FOK);
     1753                    sh_error_handle((-1), FIL__, __LINE__, flag_err, MSG_TCP_FOK);
    17481754                }
    17491755              else
     
    23892395                                     &(conn->client_entry->keyInstE));
    23902396    }
     2397  else if (msg == NULL)
     2398    {
     2399      sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
     2400                      _("msg is NULL"),
     2401                      _("sh_forward_prep_send_int: cipherInit"));
     2402    }
    23912403  else if ((S_TRUE == docrypt) && ((protocol & SH_PROTO_ENC) != 0) &&
    23922404           ((length2 + 1) > length2))
     
    24312443                            _("sh_forward_prep_send_int: blockEncrypt"));
    24322444          memcpy(q, outBlock, B_SIZ);
    2433           q += B_SIZ;
     2445          /* q += B_SIZ; *//* never read */
    24342446        }
    24352447
     
    25332545  if (val <= 0)
    25342546    SL_RETURN( (-1), _("sh_forward_set_time_limit"));
    2535 
    2536   val = (val < 0 ? 0 : val);
    25372547
    25382548  time_client_limit = (time_t) val;
     
    51425152      conns[sock].fd    = sh_tcp_sock[sock];
    51435153      conns[sock].state = CONN_READING;
    5144       high_fd = (sh_tcp_sock[sock] > high_fd) ? sh_tcp_sock[sock] : high_fd;
     5154      /* high_fd = (sh_tcp_sock[sock] > high_fd) ? sh_tcp_sock[sock] : high_fd; */
    51455155      ++sock;
    51465156    }
     
    51495159  conns[sock].fd    = pf_unix_fd;
    51505160  conns[sock].state = CONN_READING;
    5151   high_fd = (pf_unix_fd > high_fd) ? pf_unix_fd : high_fd;
     5161  /* high_fd = (pf_unix_fd > high_fd) ? pf_unix_fd : high_fd; */
    51525162
    51535163  sock_unix = sock;
     
    51755185          conns[sock].fd    = syslog_sock[s2];
    51765186          conns[sock].state = CONN_READING;
    5177           high_fd = (high_fd > conns[sock].fd) ? high_fd : conns[sock].fd;
     5187          /* high_fd = (high_fd > conns[sock].fd) ? high_fd : conns[sock].fd; */
    51785188          ++sock;
    51795189        }
  • trunk/src/sh_gpg.c

    r347 r383  
    173173
    174174  k = 0;
    175   for (i = 0; i < 127; ++i)
    176     {
    177       if (test_ptr2[i] == '\0')
    178         break;
    179       if (test_ptr2[i] != ' ')
    180         {
    181           wstrip2[k] = test_ptr2[i];
    182           ++k;
     175  if (test_ptr2)
     176    {
     177      for (i = 0; i < 127; ++i)
     178        {
     179          if (test_ptr2[i] == '\0')
     180            break;
     181          if (test_ptr2[i] != ' ')
     182            {
     183              wstrip2[k] = test_ptr2[i];
     184              ++k;
     185            }
    183186        }
    184187    }
     
    552555      pfd = val_return;
    553556      sl_close(checkfd);
    554       checkfd = -1;
     557      /* checkfd = -1; *//* never read */
    555558
    556559      sl_snprintf(pname, sizeof(pname), _("/proc/self/fd/%d"), pfd);
     
    815818        {
    816819          sl_strlcpy (sign_id, &line[25], SH_MINIBUF+1);
    817           sign_id[sl_strlen(sign_id)-1] = '\0';  /* remove trailing '"' */
     820          if (sign_id)
     821            sign_id[sl_strlen(sign_id)-1] = '\0';  /* remove trailing '"' */
    818822          have_id = GOOD;
    819823        }
     
    839843          ptr = strchr ( line, '"');
    840844          ++ptr;
    841           sl_strlcpy (sign_id, ptr, SH_MINIBUF+1);
    842           sign_id[sl_strlen(sign_id)-1] = '\0'; /* remove trailing dot */
    843           sign_id[sl_strlen(sign_id)-2] = '\0'; /* remove trailing '"' */
     845          if (ptr)
     846            {
     847              sl_strlcpy (sign_id, ptr, SH_MINIBUF+1);
     848              sign_id[sl_strlen(sign_id)-1] = '\0'; /* remove trailing dot */
     849              sign_id[sl_strlen(sign_id)-2] = '\0'; /* remove trailing '"' */
     850            }
     851          else
     852            {
     853              sl_strlcpy (sign_id, _("(null)"), SH_MINIBUF+1);
     854            }
    844855          have_id = GOOD;
    845856        }
  • trunk/src/sh_hash.c

    r371 r383  
    600600                prev->next = p->next;
    601601
    602               p = delete_db_entry(p);
     602              delete_db_entry(p);
    603603
    604604              SL_RET0(_("hash_unvisited"));
     
    693693            entries.prev->next = p->next;
    694694         
    695           p = delete_db_entry(p);
     695          delete_db_entry(p);
    696696         
    697697          goto end;
     
    915915              SL_RET0(_("hashinsert"));
    916916            }
    917           else
    918             if (p->next == NULL)
    919               {
    920                 p->next = s;
    921                 p->next->next = NULL;
    922                 SL_RET0(_("hashinsert"));
    923               }
    924           p = p->next;
     917          else if (p && p->next == NULL)
     918            {
     919              p->next = s;
     920              p->next->next = NULL;
     921              SL_RET0(_("hashinsert"));
     922            }
     923          if (p)
     924            p = p->next;
     925          else /* cannot really happen, but llvm/clang does not know */
     926            break;
    925927        }
    926928    }
     
    14701472  sl_close (fd);
    14711473  sh_hash_getline_end();
    1472   fd = -1;
     1474  /* fd = -1; */
    14731475
    14741476 unlock_and_return:
  • trunk/src/sh_html.c

    r248 r383  
    158158#endif
    159159          if (time_ptr != NULL)
    160             status = strftime (ts1, 80, _("%d-%m-%Y %H:%M:%S"), time_ptr);
     160            strftime (ts1, 80, _("%d-%m-%Y %H:%M:%S"), time_ptr);
    161161          now = time(NULL);
    162162#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_LOCALTIME_R)
     
    166166#endif
    167167          if (time_ptr != NULL)
    168             status = strftime (ts2, 80, _("%d-%m-%Y %H:%M:%S"), time_ptr);
     168            strftime (ts2, 80, _("%d-%m-%Y %H:%M:%S"), time_ptr);
    169169
    170170          sl_snprintf(outline, 1023,
     
    192192#endif
    193193              if (time_ptr != NULL)
    194                 status = strftime (ts1, 80, _("%d-%m-%Y %H:%M:%S"), time_ptr);
     194                strftime (ts1, 80, _("%d-%m-%Y %H:%M:%S"), time_ptr);
    195195              sl_snprintf(outline, 1023,
    196196                          _("<p>Last connection at %s</p>"),
     
    323323            {
    324324              entry_size = 0;
    325               add_size   = 0;
     325              /* add_size   = 0; *//* never read */
    326326              SL_RETURN( 0, _("sh_html_get_entry"));
    327327            }
  • trunk/src/sh_inotify.c

    r382 r383  
    388388  SH_MUTEX_UNLOCK(mutex_list_dormant);
    389389
     390  sh_dummy_popret = NULL;
    390391  return popret;
    391392}
  • trunk/src/sh_log_evalrule.c

    r363 r383  
    635635  if (pflag == 'K')
    636636    {
    637       nr->label   = sh_string_new_from_lchar(dstr, strlen(dstr));
     637      nr->label   = sh_string_new_from_lchar(dstr, sl_strlen(dstr));
    638638      nr->flags  |= RFL_KEEP;
    639639      nr->delay   = dsec;
     
    642642  else if (pflag == 'M')
    643643    {
    644       nr->label   = sh_string_new_from_lchar(dstr, strlen(dstr));
     644      nr->label   = sh_string_new_from_lchar(dstr, sl_strlen(dstr));
    645645      nr->flags  |= RFL_MARK;
    646646      nr->delay   = dsec;
     
    919919    DEBUG("debug: no match found\n");
    920920  /* If there was no match, this is NULL */
     921  dummy1 = NULL;
    921922  return rule;
    922923}
     
    993994      } while (group);
    994995    }
     996
     997  dummy2 = NULL;
     998  dummy3 = NULL;
    995999  return result;
    9961000}
  • trunk/src/sh_login_track.c

    r299 r383  
    298298          while (entry)
    299299            {
    300               n = fwrite(&(entry->data), sizeof(struct sh_track_entry_data), 1, fp);
     300              fwrite(&(entry->data), sizeof(struct sh_track_entry_data),
     301                     1, fp);
    301302              entry = entry->next;
    302303            }
     
    426427    }
    427428
    428   while (*p && (*p == ' ' || *p == '\t')) ++p;
    429 
    430   if (*p && (i < SH_LTRACK_USIZE) && (*p == ':'))
     429  while (p && *p && (*p == ' ' || *p == '\t')) ++p;
     430
     431  if (p && *p && (i < SH_LTRACK_USIZE) && (*p == ':'))
    431432    {
    432433      user[i] = '\0';
     
    970971
    971972  urecord    = load_data(user);
    972   last_login = (urecord->head).last_login;
    973 
    974   urecord = load_data(user);
    975973  last_login = (urecord->head).last_login;
    976974
  • trunk/src/sh_mail.c

    r379 r383  
    458458}
    459459
    460 void sh_mail_signature_block (sh_string  * sigMsg, char * recipient,
    461                               char * bufcompress)
     460sh_string * sh_mail_signature_block (sh_string  * sigMsg, char * recipient,
     461                                     char * bufcompress)
    462462{
    463463  time_t         id_audit;
     
    511511    sigMsg     = sh_string_add_from_char(sigMsg, _("-----END MESSAGE-----"));
    512512
    513     return;
     513    return sigMsg;
    514514}
    515515
     
    599599     * how to filter messages. */
    600600
    601     theMsg = sh_string_new_from_lchar(message, strlen(message));
     601    theMsg = sh_string_new_from_lchar(message, sl_strlen(message));
     602    if (!theMsg)
     603      {
     604        SL_RETURN((-1), _("sh_mail_msg"));
     605      }
    602606
    603607    /* ---------- Header  ---------------------------------------- */
     
    694698                        sh_string  * sigMsg  = sh_string_new (0);
    695699
    696                         sh_mail_signature_block (sigMsg,
    697                                                 sh_string_str(address_list->recipient),
    698                                                 bufcompress);
     700                        sigMsg = sh_mail_signature_block (sigMsg,
     701                                                          sh_string_str(address_list->recipient),
     702                                                          bufcompress);
    699703
    700704                        wrlen = fwrite (sh_string_str(sigMsg), 1,
     
    746750                sh_string  * sigMsg  = sh_string_new (0);
    747751               
    748                 sh_mail_signature_block (sigMsg,
    749                                         NULL,
    750                                         bufcompress);
     752                sigMsg  = sh_mail_signature_block (sigMsg,
     753                                                  NULL,
     754                                                  bufcompress);
    751755               
    752756                wrlen = fwrite (sh_string_str(sigMsg), 1,
     
    774778              }
    775779
    776             sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_SRV_FAIL,
    777                              _("mail"), sh_string_str(ma_address->recipient));
     780            if (ma_address)
     781              sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_SRV_FAIL,
     782                               _("mail"),
     783                               sh_string_str(ma_address->recipient));
    778784            errcount = address_num;
    779785            ++sh.statistics.mail_failed;
     
    16521658    }
    16531659
    1654   ret = 0;
     1660
    16551661  header  = (HEADER *) reply;
    16561662
     
    17531759      /* CLASS (re-use 'type' var)
    17541760       */
    1755       type = get_short (comp_dn);
     1761      /* type = get_short (comp_dn); *//* don't care */
    17561762      comp_dn += 2;
    17571763      if (comp_dn >= eom)
  • trunk/src/sh_portcheck.c

    r380 r383  
    605605      ptr = ptr->next;
    606606    }
     607
     608  sh_dummy_ptr = NULL;
     609  sh_dummy_pre = NULL;
     610
    607611  return;
    608612}
     
    15461550  } while (*str);
    15471551
     1552  sh_dummy_str = NULL;
    15481553  return 0;
    15491554}
     
    16531658        {
    16541659          if (portchk_debug)
    1655             fprintf(stderr, _("add_required_port\n"));
     1660            fprintf(stderr, _("add_required_port %d\n"), (int) port);
    16561661          sh_portchk_add_to_list (proto,   -1, &saddr,  buf, type, SH_PORT_UNKN);
    16571662        }
  • trunk/src/sh_processcheck.c

    r379 r383  
    460460      list = list->next;
    461461    }
     462
     463  sh_dummy_watchlist = NULL;
     464  return;
    462465}
    463466
     
    518521  SL_ENTER(_("sh_prochk_set_pspath"));
    519522
    520   if (!str && ('/' != str[0]))
     523  if (!str || ('/' != str[0]))
    521524    SL_RETURN((-1), _("sh_prochk_set_pspath"));
    522525  if (sh_prochk_pspath)
  • trunk/src/sh_readconf.c

    r367 r383  
    142142  while (tmp && isspace((int)*tmp)) ++tmp;
    143143 
    144   if (tmp[0] == '$' && tmp[1] == '(')
     144  if (tmp && tmp[0] == '$' && tmp[1] == '(')
    145145    {
    146146      size_t len = strlen(tmp);
  • trunk/src/sh_restrict.c

    r341 r383  
    107107  SL_ENTER(_("matches_prefix"));
    108108
    109   path_len = sl_strlen(path);
    110   pref_len = sl_strlen(prefix);
    111  
    112   if (path_len >= pref_len)
    113     {
    114       if (0 == strncmp(path, prefix, pref_len))
    115         {
    116           SL_RETURN(1, _("matches_prefix"));
     109  if (path && prefix)
     110    {
     111      path_len = sl_strlen(path);
     112      pref_len = sl_strlen(prefix);
     113     
     114      if (path_len >= pref_len)
     115        {
     116          if (0 == strncmp(path, prefix, pref_len))
     117            {
     118              SL_RETURN(1, _("matches_prefix"));
     119            }
    117120        }
    118121    }
  • trunk/src/sh_socket.c

    r362 r383  
    997997                   (struct sockaddr *) & name, size);
    998998  */
    999   nbytes = send (talkfd, _("END"), 4, 0);
     999  /* nbytes = *//* never read */ send (talkfd, _("END"), 4, 0);
    10001000  sl_close_fd(FIL__, __LINE__, talkfd);
    10011001  return 0;
  • trunk/src/sh_string.c

    r276 r383  
    4747      if (*s)
    4848        {
    49           a = s;
    50 
    5149          /* move a to next delim
    5250           */
     
    257255  char * s = line;
    258256  char * p;
     257  unsigned int sind = (prefix) ? strlen(prefix) : 0;
    259258
    260259  while ( *s && isspace((int)*s) ) ++s;
    261260  if (prefix && 0 != strncmp(s, prefix, strlen(prefix)))
    262261    return NULL;
    263   s = &s[strlen(prefix)];
     262  s = &s[sind];
    264263  while ( *s && isspace((int)*s) ) ++s;
    265264  if (!s || (*s != '('))
     
    437436  s      = SH_ALLOC(sizeof(sh_string));
    438437  s->str = SH_ALLOC(len+1);
    439   memcpy(s->str, str, len);
     438  if (str)
     439    memcpy(s->str, str, len);
     440  else
     441    s->str[0] = '\0';
    440442  s->str[len] = '\0';
    441443  s->siz = len+1;
     
    599601
    600602  curr = -1;
    601   last = -1;
    602603
    603604  for (i = 0; i < ovecnum; ++i)
  • trunk/src/sh_suidchk.c

    r381 r383  
    927927          SH_FREE(tmp);
    928928          SH_FREE(msg);
    929           cperm_status = -1;
    930929        }
    931930    }
     
    15391538  ShSuidchkExclude = sh_util_strdup (c);
    15401539  ExcludeLen       = sl_strlen (ShSuidchkExclude);
    1541   if (ShSuidchkExclude[ExcludeLen-1] == '/')
     1540  if (ShSuidchkExclude && ShSuidchkExclude[ExcludeLen-1] == '/')
    15421541    {
    15431542      ShSuidchkExclude[ExcludeLen-1] = '\0';
  • trunk/src/sh_tiger0.c

    r300 r383  
    287287        sh.statistics.bytes_hashed += tt;
    288288       
    289         bptr = buffer; tt = 0;
     289        tt = 0;
    290290        for (i = 0; i < blk; ++i)
    291291          {
     
    366366        /* MAY_LOCK */
    367367        sh.statistics.bytes_hashed += 64;
    368         ++nblocks; ncount = 0;
     368        ++nblocks;
     369#ifdef TIGER_DBG
     370        ncount = 0;
     371#endif
    369372        sl_memset(bbuf, 0, 56 );
    370373      }
  • trunk/src/sh_tools.c

    r379 r383  
    339339            break;
    340340
    341           c = *p;
     341
    342342
    343343          switch (*p) {
     
    516516{
    517517  sin_cache * check_cache = conn_cache;
    518   sin_cache * old_entry   = conn_cache;
     518  sin_cache * old_entry;
    519519
    520520  SL_ENTER(_("delete_cache"));
  • trunk/src/sh_unix.c

    r381 r383  
    11081108  int    status;
    11091109  int    level;
    1110   uid_t  ff_euid;
     1110  uid_t  ff_euid = (uid_t) -1;
    11111111
    11121112  SL_ENTER(_("tf_trust_check"));
     
    11361136          aud_exit (FIL__, __LINE__, EXIT_FAILURE);
    11371137        }
    1138       ff_euid = tempres->pw_uid;
     1138      else
     1139        {
     1140          ff_euid = tempres->pw_uid;
     1141        }
    11391142#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
    11401143      SH_FREE(buffer);
     
    26232626static void sh_userid_additem(struct user_id * list, struct user_id * item)
    26242627{
    2625   while (list && list->next)
    2626     list = list->next;
    2627   list->next = item;
     2628  if (list)
     2629    {
     2630      while (list && list->next)
     2631        list = list->next;
     2632      list->next = item;
     2633    }
    26282634  return;
    26292635}
  • trunk/src/sh_utmp.c

    r363 r383  
    872872  SL_ENTER(_("sh_utmp_addlogin"));
    873873
     874  if (ut->ut_line[0] == '\0')
     875    SL_RET0(_("sh_utmp_addlogin"));
     876
     877  /* for some stupid reason, AIX repeats the wtmp entry for logouts
     878   * with ssh
     879   */
     880  if (memcmp (&save_utmp, ut, sizeof(struct SH_UTMP_S)) == 0)
     881    {
     882      memset(&save_utmp, (int) '\0', sizeof(struct SH_UTMP_S));
     883      SL_RET0(_("sh_utmp_addlogin"));
     884    }
     885  memcpy (&save_utmp, ut, sizeof(struct SH_UTMP_S));
     886
    874887  /* Take the address to keep gcc from putting them into registers.
    875888   * Avoids the 'clobbered by longjmp' warning.
     
    877890  sh_dummy_userold = (void*) &userold;
    878891  sh_dummy_user    = (void*) &user;
    879 
    880   if (ut->ut_line[0] == '\0')
    881     SL_RET0(_("sh_utmp_addlogin"));
    882 
    883   /* for some stupid reason, AIX repeats the wtmp entry for logouts
    884    * with ssh
    885    */
    886   if (memcmp (&save_utmp, ut, sizeof(struct SH_UTMP_S)) == 0)
    887     {
    888       memset(&save_utmp, (int) '\0', sizeof(struct SH_UTMP_S));
    889       SL_RET0(_("sh_utmp_addlogin"));
    890     }
    891   memcpy (&save_utmp, ut, sizeof(struct SH_UTMP_S));
    892 
    893892
    894893  /* ------- find user --------
     
    993992     
    994993      sh_utmp_login_morechecks(ut);
    995       SL_RET0(_("sh_utmp_addlogin"));
     994      goto out;
    996995    }
    997996
     
    10521051          SH_MUTEX_UNLOCK(mutex_thread_nolog);
    10531052        }
    1054       SL_RET0(_("sh_utmp_addlogin"));
     1053      goto out;
    10551054    }
    10561055
    10571056  /* default */
    1058   SL_RET0(_("sh_utmp_addlogin"));
     1057  goto out;
    10591058
    10601059  /* #ifdef HAVE_UTTYPE                   */
     
    11361135    }
    11371136
     1137#endif
     1138
     1139 out:
     1140  sh_dummy_user    = NULL;
     1141  sh_dummy_userold = NULL;
     1142
    11381143  SL_RET0(_("sh_utmp_addlogin"));
    1139 #endif
    11401144}
    11411145
     
    12141218    {
    12151219      while (this_read < lastread) {
    1216         ut = sh_utmp_getutent();
     1220        (void) sh_utmp_getutent();
    12171221        ++this_read;
    12181222      }
  • trunk/src/slib.c

    r371 r383  
    931931  else if (src == NULL)
    932932    {
    933       if (siz > 0)
     933      if (dst && siz > 0)
    934934        dst[0] = '\0';
    935935      return SL_ENONE;
     
    28352835   */
    28362836  bytecount    = 0;
    2837   bytewritten  = 0;
     2837
    28382838  while (bytecount < nbytes)
    28392839    {   
    2840       if ((bytewritten = write (fd, msg, nbytes-bytecount)) > 0)
     2840      bytewritten = write (fd, msg, nbytes-bytecount);
     2841
     2842      if (bytewritten > 0)
    28412843        {
    28422844          bytecount += bytewritten;
  • trunk/src/zAVLTree.c

    r363 r383  
    366366  depthdiff = R_DEPTH(avlnode) - L_DEPTH(avlnode);
    367367
    368   if (depthdiff <= -2) {
     368  if (depthdiff <= -2 && avlnode->left) {
    369369    child = avlnode->left;
    370370
     
    384384    else {
    385385      gchild = child->right;
    386       avlnode->left = gchild->right;
    387       if (avlnode->left != NULL)
    388         avlnode->left->parent = avlnode;
    389       avlnode->depth = CALC_DEPTH(avlnode);
    390       child->right = gchild->left;
    391       if (child->right != NULL)
    392         child->right->parent = child;
    393       child->depth = CALC_DEPTH(child);
    394       gchild->right = avlnode;
    395       if (gchild->right != NULL)
    396         gchild->right->parent = gchild;
    397       gchild->left = child;
    398       if (gchild->left != NULL)
    399         gchild->left->parent = gchild;
    400       gchild->depth = CALC_DEPTH(gchild);
    401       *superparent = gchild;
    402       gchild->parent = origparent;
    403     }
    404   }
    405 
    406   else if (depthdiff >= 2) {
     386      if (gchild)
     387        {
     388          avlnode->left = gchild->right;
     389          if (avlnode->left != NULL)
     390            avlnode->left->parent = avlnode;
     391          avlnode->depth = CALC_DEPTH(avlnode);
     392          child->right = gchild->left;
     393          if (child->right != NULL)
     394            child->right->parent = child;
     395          child->depth = CALC_DEPTH(child);
     396          gchild->right = avlnode;
     397          if (gchild->right != NULL)
     398            gchild->right->parent = gchild;
     399          gchild->left = child;
     400          if (gchild->left != NULL)
     401            gchild->left->parent = gchild;
     402          gchild->depth = CALC_DEPTH(gchild);
     403          *superparent = gchild;
     404          gchild->parent = origparent;
     405        }
     406    }
     407  }
     408
     409  else if (depthdiff >= 2 && avlnode->right) {
    407410    child = avlnode->right;
    408411
     
    422425    else {
    423426      gchild = child->left;
    424       avlnode->right = gchild->left;
    425       if (avlnode->right != NULL)
    426         avlnode->right->parent = avlnode;
    427       avlnode->depth = CALC_DEPTH(avlnode);
    428       child->left = gchild->right;
    429       if (child->left != NULL)
    430         child->left->parent = child;
    431       child->depth = CALC_DEPTH(child);
    432       gchild->left = avlnode;
    433       if (gchild->left != NULL)
    434         gchild->left->parent = gchild;
    435       gchild->right = child;
    436       if (gchild->right != NULL)
    437         gchild->right->parent = gchild;
    438       gchild->depth = CALC_DEPTH(gchild);
    439       *superparent = gchild;
    440       gchild->parent = origparent;
     427      if (gchild)
     428        {
     429          avlnode->right = gchild->left;
     430          if (avlnode->right != NULL)
     431            avlnode->right->parent = avlnode;
     432          avlnode->depth = CALC_DEPTH(avlnode);
     433          child->left = gchild->right;
     434          if (child->left != NULL)
     435            child->left->parent = child;
     436          child->depth = CALC_DEPTH(child);
     437          gchild->left = avlnode;
     438          if (gchild->left != NULL)
     439            gchild->left->parent = gchild;
     440          gchild->right = child;
     441          if (gchild->right != NULL)
     442            gchild->right->parent = gchild;
     443          gchild->depth = CALC_DEPTH(gchild);
     444          *superparent = gchild;
     445          gchild->parent = origparent;
     446        }
    441447    }
    442448  }
Note: See TracChangeset for help on using the changeset viewer.