Changeset 541


Ignore:
Timestamp:
Jan 16, 2019, 11:57:48 PM (6 years ago)
Author:
katerina
Message:

Fix for ticket #433 (coding standardisation).

Location:
trunk/src
Files:
30 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/samhain.c

    r539 r541  
    838838    (void) sh_unix_rm_pid_file ();
    839839  if (skey != NULL)
    840     memset (skey, (int) '\0', sizeof(sh_key_t));
     840    memset (skey, 0, sizeof(sh_key_t));
    841841 
    842842  /* --- Exit. ---

  • trunk/src/samhain_setpwd.c

    r415 r541  
    246246  char * oldpwd = (char *) malloc(5 * 8 + 2);
    247247
    248   memset (newpwd, '\0', 5 * 8 + 2);
    249   memset (oldpwd, '\0', 5 * 8 + 2);
     248  memset (newpwd, 0, 5 * 8 + 2);
     249  memset (oldpwd, 0, 5 * 8 + 2);
    250250
    251251

  • trunk/src/sh_audit.c

    r516 r541  
    148148    }
    149149
    150   memset(&state, '\0', sizeof(state));
     150  memset(&state, 0, sizeof(state));
    151151
    152152  while (ausearch_next_event(au) == 1)

  • trunk/src/sh_database.c

    r539 r541  
    284284static void init_db_entry (dbins * ptr)
    285285{
    286   memset (ptr, (int) '\0', sizeof(dbins));
     286  memset (ptr, 0, sizeof(dbins));
    287287  ptr->next = NULL;
    288288  return;

  • trunk/src/sh_dbIO.c

    r538 r541  
    460460              if (1 == 0)
    461461                hexdump((unsigned char *)&old_struct, sizeof(old_struct));
    462               memset(&try_struct, '\0', sizeof(try_struct));
     462              memset(&try_struct, 0, sizeof(try_struct));
    463463              if (!memcmp(&old_struct, &try_struct, sizeof(try_struct)))
    464464                return 0; /* NULL read */
    … …  
    14371437         
    14381438  if (!buf) {
    1439     memset(&p, '\0', sizeof(sh_filestore_t));
     1439    memset(&p, 0, sizeof(sh_filestore_t));
    14401440  }
    14411441

  • trunk/src/sh_entropy.c

    r481 r541  
    334334    nbytes = KEY_BYT;
    335335
    336   memset(nbuf, '\0', nbytes);
     336  memset(nbuf, 0, nbytes);
    337337
    338338#ifdef NAME_OF_DEV_URANDOM
    … …  
    370370      /* -- Add previous entropy into the new pool. --
    371371       */
    372       memset(addbuf, '\0', sizeof(addbuf));
     372      memset(addbuf, 0, sizeof(addbuf));
    373373      for (i = 0; i < m_count; ++i)
    374374        addbuf[i]         = nbuf[i];
    … …  
    378378                                              TIGER_DATA, 2 * KEY_BYT,
    379379                                              kbuf, KEY_BYT/sizeof(UINT32));
    380       memset(addbuf, '\0', sizeof(addbuf));
     380      memset(addbuf, 0, sizeof(addbuf));
    381381     
    382382      /* -- Give out nbytes bytes from the new pool. --
    … …  
    390390        }
    391391      SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
    392       memset (keybuf, '\0', KEY_BYT);
    393       memset (kbuf,   '\0', sizeof(kbuf));
     392      memset (keybuf, 0, KEY_BYT);
     393      memset (kbuf,   0, sizeof(kbuf));
    394394     
    395395      SL_RETURN(0, _("sh_entropy"));
    … …  
    416416#endif
    417417#ifndef FD_ZERO
    418 #define FD_ZERO(p)      memset((char *)(p), '\0', sizeof(*(p)))
     418#define FD_ZERO(p)      memset((char *)(p), 0, sizeof(*(p)))
    419419#endif
    420420
    … …  
    953953                                            TIGER_DATA, sizeof(tseed),
    954954                                            kbuf, KEY_BYT/sizeof(UINT32));
    955     memset(addbuf, '\0', sizeof(addbuf));
     955    memset(addbuf, 0, sizeof(addbuf));
    956956    for (i = 0; i < KEY_BYT; ++i)
    957957      {
    … …  
    974974      /* add previous entropy into the new pool
    975975       */
    976       memset(addbuf, '\0', sizeof(addbuf));
     976      memset(addbuf, 0, sizeof(addbuf));
    977977      for (i = 0; i < KEY_BYT; ++i)
    978978        {
    … …  
    983983                                              TIGER_DATA, sizeof(addbuf),
    984984                                              kbuf, KEY_BYT/sizeof(UINT32));
    985       memset(addbuf, '\0', sizeof(addbuf));
     985      memset(addbuf, 0, sizeof(addbuf));
    986986     
    987987      /* store in system pool
    … …  
    992992      skey->poolc = KEY_BYT;
    993993      SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
    994       memset (buffer, '\0', BUF_ENT+2);
    995       memset (keybuf, '\0', KEY_BYT);
     994      memset (buffer, 0, BUF_ENT+2);
     995      memset (keybuf, 0, KEY_BYT);
    996996      SH_FREE(buffer);
    997997    }
    … …  
    10301030  for (count = 0; count < 20; ++count)
    10311031    {
    1032       memset(skey->poolv, '\0', KEY_BYT);
     1032      memset(skey->poolv, 0, KEY_BYT);
    10331033      skey->poolc = 0;
    10341034
    … …  
    10361036      CuAssertTrue(tc, 0 == status);
    10371037     
    1038       memset(skey->poolv, '\0', KEY_BYT);
     1038      memset(skey->poolv, 0, KEY_BYT);
    10391039      skey->poolc = 0;
    10401040

  • trunk/src/sh_err_console.c

    r489 r541  
    141141  } while (rc < 0 && errno == EINTR);
    142142
    143   memset(&recv_msg, '\0', sizeof(recv_msg));
     143  memset(&recv_msg, 0, sizeof(recv_msg));
    144144  return;
    145145}
    … …  
    190190  if (count > 1)
    191191    {
    192       memset(recv_msg, '\0', MY_MAX_MSG+1);
     192      memset(recv_msg, 0, MY_MAX_MSG+1);
    193193      SH_FREE(recv_msg);
    194194      SL_RETURN(-1, _("push_message_queue"));
    … …  
    214214        TPT(( 0, FIL__, __LINE__, _("msg=<msgsnd: %s> errno=<%d>\n"),
    215215              sh_error_message(errno, errbuf, sizeof(errbuf)), errno));
    216         memset(recv_msg, '\0', MY_MAX_MSG+1);
     216        memset(recv_msg, 0, MY_MAX_MSG+1);
    217217        SH_FREE(recv_msg);
    218218        SL_RETURN(-1, _("push_message_queue"));
    … …  
    220220    }
    221221
    222   memset(recv_msg, '\0', MY_MAX_MSG+1);
     222  memset(recv_msg, 0, MY_MAX_MSG+1);
    223223  SH_FREE(recv_msg);
    224224

  • trunk/src/sh_err_log.c

    r516 r541  
    743743      current->service_failure = 0;
    744744      current->log_start       = S_TRUE;
    745       memset(current->sigkey_old, (int)'\0', KEY_LEN+1);
    746       memset(current->sigkey_new, (int)'\0', KEY_LEN+1);
    747       memset(current->crypto,     (int)'\0', KEY_LEN+1);
     745      memset(current->sigkey_old, 0, KEY_LEN+1);
     746      memset(current->sigkey_new, 0, KEY_LEN+1);
     747      memset(current->crypto,     0, KEY_LEN+1);
    748748      current->next            = logfile_list;
    749749      logfile_list             = current;
    … …  
    944944
    945945
    946       memset (crypto, (int) '\0', KEY_LEN);
     946      memset (crypto, 0, KEY_LEN);
    947947      sh.flag.log_start    = S_FALSE; 
    948948      current->log_start   = S_FALSE;
    … …  
    10461046  /* --- Clean up and free record. ---
    10471047   */
    1048   memset (log_msg.msg,       (int)'\0', (size_t)(status + 2*KEY_LEN + 32));
    1049   memset (log_msg.signature, (int)'\0', KEY_LEN);
     1048  memset (log_msg.msg,       0, (size_t)(status + 2*KEY_LEN + 32));
     1049  memset (log_msg.signature, 0, KEY_LEN);
    10501050  (void) sh_unix_munlock (log_msg.msg, 
    10511051                          (size_t)(status + 2*KEY_LEN + 32));

  • trunk/src/sh_error.c

    r510 r541  
    14421442  sh_replace_free(hexmsg);
    14431443
    1444   memset ( lmsg, (int) '\0', sizeof(struct _log_t) );
     1444  memset ( lmsg, 0, sizeof(struct _log_t) );
    14451445  MUNLOCK( (char *) lmsg,       sizeof(struct _log_t) );
    14461446  SH_FREE( lmsg );

  • trunk/src/sh_filter.c

    r232 r541  
    293293  sh_filter_type * filter = SH_ALLOC(sizeof(sh_filter_type));
    294294
    295   memset(filter, '\0', sizeof(sh_filter_type));
     295  memset(filter, 0, sizeof(sh_filter_type));
    296296  filter->for_c  = 0;
    297297  filter->fand_c = 0;

  • trunk/src/sh_gpg.c

    r481 r541  
    457457       * gpg.
    458458       */
    459       memset (skey, '\0', sizeof(sh_key_t));
     459      memset (skey, 0, sizeof(sh_key_t));
    460460      aud_setuid(FIL__, __LINE__, geteuid());
    461461     

  • trunk/src/sh_ipvx.c

    r539 r541  
    208208void sh_ipvx_save(struct sh_sockaddr * ss, int sa_family, struct sockaddr * sa)
    209209{
    210   /* memset(ss, '\0', sizeof(struct sh_sockaddr)); */
    211 
    212210  switch (sa_family)
    213211    {
    … …  
    278276  struct addrinfo *res;
    279277
    280   memset(&hints, '\0', sizeof(hints));
     278  memset(&hints, 0, sizeof(hints));
    281279  hints.ai_family = PF_UNSPEC;
    282280  hints.ai_flags  = AI_NUMERICHOST;
    … …  
    286284    return 0;
    287285
    288   memset(ss, '\0', sizeof(struct sh_sockaddr));
     286  memset(ss, 0, sizeof(struct sh_sockaddr));
    289287  switch(res->ai_family)
    290288    {
    … …  
    514512  sl_snprintf(sport, sizeof(sport), "%d", port);
    515513
    516   memset(&hints, '\0', sizeof(hints));
     514  memset(&hints, 0, sizeof(hints));
    517515  hints.ai_socktype = SOCK_STREAM;
    518516  hints.ai_flags = AI_ADDRCONFIG;

  • trunk/src/sh_log_check.c

    r481 r541  
    601601      SH_MUTEX_UNLOCK(mutex_thread_nolog);
    602602
    603       memset (&(logfile->offset), '\0', sizeof(fpos_t));
     603      memset (&(logfile->offset), 0, sizeof(fpos_t));
    604604      logfile->flags |= SH_LOGFILE_REWIND;
    605605      return 0;
    … …  
    623623          /* done with rotated file, start with current file
    624624           */
    625           memset (&(logfile->offset), '\0', sizeof(fpos_t));
     625          memset (&(logfile->offset), 0, sizeof(fpos_t));
    626626          logfile->flags    |= SH_LOGFILE_REWIND;
    627627          logfile->flags    &= ~SH_LOGFILE_MOVED;
    … …  
    646646          else
    647647            {
    648               memset (&(logfile->offset), '\0', sizeof(fpos_t));
     648              memset (&(logfile->offset), 0, sizeof(fpos_t));
    649649              logfile->flags    |= SH_LOGFILE_REWIND;
    650650              logfile->inode     = buf.st_ino;
    … …  
    965965      if (status != 1)
    966966        {
    967           memset(s, '\0', size);
     967          memset(s, 0, size);
    968968          if (ferror(logfile->fp) && (logfile->flags & SH_LOGFILE_PIPE) == 0)
    969969            {

  • trunk/src/sh_log_evalrule.c

    r539 r541  
    186186
    187187  ng = SH_ALLOC(sizeof(struct sh_geval));
    188   memset(ng, '\0', sizeof(struct sh_geval));
     188  memset(ng, 0, sizeof(struct sh_geval));
    189189
    190190  ng->label       = sh_string_new_from_lchar(splits[0], lengths[0]);
    … …  
    294294
    295295  nh = SH_ALLOC(sizeof(struct sh_heval));
    296   memset(nh, '\0', sizeof(struct sh_heval));
     296  memset(nh, 0, sizeof(struct sh_heval));
    297297
    298298  nh->hostname = host;
    … …  
    362362
    363363  nq = SH_ALLOC(sizeof(struct sh_qeval));
    364   memset(nq, '\0', sizeof(struct sh_qeval));
     364  memset(nq, 0, sizeof(struct sh_qeval));
    365365
    366366  nq->label = sh_string_new_from_lchar(splits[0], lengths[0]);
    … …  
    620620
    621621  nr = SH_ALLOC(sizeof(struct sh_geval));
    622   memset(nr, '\0', sizeof(struct sh_geval));
     622  memset(nr, 0, sizeof(struct sh_geval));
    623623
    624624  nr->label       = NULL;
    … …  
    11421142
    11431143      counter = SH_ALLOC(sizeof(struct sh_ceval));
    1144       memset(counter, '\0', sizeof(struct sh_ceval));
     1144      memset(counter, 0, sizeof(struct sh_ceval));
    11451145
    11461146      counter->hostname    = sh_string_new_from_lchar(sh_string_str(host),

  • trunk/src/sh_log_parse_apache.c

    r481 r541  
    354354          char * ptr = NULL;
    355355
    356           memset(&btime, '\0', sizeof(struct tm));
     356          memset(&btime, 0, sizeof(struct tm));
    357357          btime.tm_isdst = -1;
    358358         

  • trunk/src/sh_log_parse_samba.c

    r357 r541  
    7575          char * ptr;
    7676
    77           memset(&btime, '\0', sizeof(struct tm));
     77          memset(&btime, 0, sizeof(struct tm));
    7878          btime.tm_isdst = -1;
    7979

  • trunk/src/sh_log_parse_syslog.c

    r481 r541  
    9494      size_t lengths[3];
    9595
    96       memset(&btime, '\0', sizeof(struct tm));
     96      memset(&btime, 0, sizeof(struct tm));
    9797      btime.tm_isdst = -1;
    9898

  • trunk/src/sh_login_track.c

    r405 r541  
    232232
    233233  urecord = SH_ALLOC(sizeof(struct sh_track));
    234   memset(urecord, '\0', sizeof(struct sh_track));
     234  memset(urecord, 0, sizeof(struct sh_track));
    235235
    236236  uhead = &(urecord->head);
    … …  
    445445            {
    446446              u = SH_ALLOC(sizeof(struct sh_track_dates));
    447               memset(u, '\0', sizeof(struct sh_track_dates));
     447              memset(u, 0, sizeof(struct sh_track_dates));
    448448              sl_strlcpy(u->user, user, SH_LTRACK_USIZE);
    449449              flag = 1;
    … …  
    913913    {
    914914      entry = SH_ALLOC(sizeof(struct sh_track_entry));
    915       memset(entry, '\0', sizeof(struct sh_track_entry));
     915      memset(entry, 0, sizeof(struct sh_track_entry));
    916916      (entry->data).last_login    = time;
    917917      (entry->data).array[index]  = 1;

  • trunk/src/sh_port2proc.c

    r481 r541  
    635635            memcpy(xbuf, buf, len0);
    636636          else
    637             memset(xbuf, '\0', len);
     637            memset(xbuf, 0, len);
    638638          SH_FREE(buf);
    639639        }
    … …  
    823823
    824824                sock = SH_ALLOC(sizeof *sock);
    825                 memset(sock, '\0', sizeof (*sock));
     825                memset(sock, 0, sizeof (*sock));
    826826
    827827#ifndef in6p_lport

  • trunk/src/sh_portcheck.c

    r539 r541  
    14101410  SH_MUTEX_UNLOCK(mutex_resolv);
    14111411#else
    1412   memset(&hints, '\0', sizeof(hints));
     1412  memset(&hints, 0, sizeof(hints));
    14131413  hints.ai_family = PF_UNSPEC;
    14141414  hints.ai_flags  = AI_ADDRCONFIG;

  • trunk/src/sh_registry.c

    r539 r541  
    350350  struct store2db save;
    351351
    352   memset(&save, '\0', sizeof(struct store2db));
     352  memset(&save, 0, sizeof(struct store2db));
    353353  sh_hash_db2pop (path, &save);
    354354   
    … …  
    682682      struct store2db save;
    683683
    684       memset(&save, '\0', sizeof(struct store2db));
     684      memset(&save, 0, sizeof(struct store2db));
    685685
    686686      if (tPath)
    … …  
    774774      struct store2db save;
    775775
    776       memset(&save, '\0', sizeof(struct store2db));
     776      memset(&save, 0, sizeof(struct store2db));
    777777     
    778778      save.val0 = totalSize;

  • trunk/src/sh_tiger0.c

    r539 r541  
    379379        ncount = 0;
    380380#endif
    381         sl_memset(bbuf, 0, 56 );
     381        memset(bbuf, 0, 56 );
    382382      }
    383383
    … …  
    402402#endif
    403403
    404     sl_memset (bbuf,   '\0', sizeof(bbuf));
    405     sl_memset (buffer, '\0', sizeof(buffer));
     404    memset (bbuf,   0, sizeof(bbuf));
     405    memset (buffer, 0, sizeof(buffer));
    406406
    407407    if (what == TIGER_FILE)

  • trunk/src/sh_tools.c

    r539 r541  
    7070#endif
    7171#ifndef FD_ZERO
    72 #define FD_ZERO(p)      memset((char *)(p), '\0', sizeof(*(p)))
     72#define FD_ZERO(p)      memset((char *)(p), 0, sizeof(*(p)))
    7373#endif
    7474
    … …  
    135135  int             res;
    136136
    137   memset (&hints, '\0', sizeof (hints));
     137  memset (&hints, 0, sizeof (hints));
    138138  hints.ai_flags = AI_PASSIVE | AI_ADDRCONFIG;
    139139  hints.ai_socktype = SOCK_STREAM;
    … …  
    180180  int sd;
    181181
    182   memset(&sin, '\0', sizeof(sin));
     182  memset(&sin, 0, sizeof(sin));
    183183  sin.sin_family = AF_INET;
    184184  if (inet_aton(str, &(sin.sin_addr)))
    … …  
    915915        fputs(_("-03- not cached\n"), stderr);
    916916
    917       memset (&hints, '\0', sizeof (hints));
     917      memset (&hints, 0, sizeof (hints));
    918918      hints.ai_flags = AI_ADDRCONFIG;
    919919#if defined(AI_CANONNAME)
    … …  
    16681668  if ((i_blk*16) > payload_size && !oflow)
    16691669    {
    1670       memset(&full_ret[16+payload_size], '\0', (i_blk*16) - payload_size);
     1670      memset(&full_ret[16+payload_size], 0, (i_blk*16) - payload_size);
    16711671      payload_size = i_blk * 16;
    16721672    }
    1673   memset(&full_ret[16+payload_size], '\0', i_epad*16);
     1673  memset(&full_ret[16+payload_size], 0, i_epad*16);
    16741674
    16751675  /* rewrite header

  • trunk/src/sh_unix.c

    r539 r541  
    8383#endif
    8484#ifndef FD_ZERO
    85 #define FD_ZERO(p)      memset((char *)(p), '\0', sizeof(*(p)))
     85#define FD_ZERO(p)      memset((char *)(p), 0, sizeof(*(p)))
    8686#endif
    8787
    … …  
    514514      ++immediate_exit_normal;
    515515      if ((skey != NULL) && (immediate_exit_normal == 2))
    516         memset (skey, '\0', sizeof(sh_key_t));
     516        memset (skey, 0, sizeof(sh_key_t));
    517517      if (immediate_exit_normal == 2)
    518518        {
    … …  
    579579  ++immediate_exit_fast;
    580580  if (skey != NULL && immediate_exit_fast < 2)
    581     memset (skey, '\0', sizeof(sh_key_t));
     581    memset (skey, 0, sizeof(sh_key_t));
    582582  if (immediate_exit_fast < 2)
    583583    safe_logger (mysignal, 0, NULL);
    … …  
    591591      ++immediate_exit_fast;
    592592      if (skey != NULL)
    593         memset (skey, '\0', sizeof(sh_key_t));
     593        memset (skey, 0, sizeof(sh_key_t));
    594594      close_ipc ();
    595595      safe_logger (mysignal, 0, NULL);
    … …  
    631631
    632632  if (skey != NULL)
    633     memset (skey, '\0', sizeof(sh_key_t));
     633    memset (skey, 0, sizeof(sh_key_t));
    634634  close_ipc ();
    635635

  • trunk/src/sh_utils.c

    r504 r541  
    10881088  SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
    10891089
    1090   memset(taus_svec, '\0', TAUS_SAMPLE * sizeof(UINT32));
     1090  memset(taus_svec, 0, TAUS_SAMPLE * sizeof(UINT32));
    10911091
    10921092  return retval;

  • trunk/src/sh_utmp.c

    r481 r541  
    875875  if (memcmp (&save_utmp, ut, sizeof(struct SH_UTMP_S)) == 0)
    876876    {
    877       memset(&save_utmp, (int) '\0', sizeof(struct SH_UTMP_S));
     877      memset(&save_utmp, 0, sizeof(struct SH_UTMP_S));
    878878      SL_RET0(_("sh_utmp_addlogin"));
    879879    }

  • trunk/src/sh_xfer_client.c

    r489 r541  
    9797#endif
    9898#ifndef FD_ZERO
    99 #define FD_ZERO(p)      memset((char *)(p), '\0', sizeof(*(p)))
     99#define FD_ZERO(p)      memset((char *)(p), 0, sizeof(*(p)))
    100100#endif
    101101
    … …  
    10511051      xfer_timeout_val *= 2;
    10521052      sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_NOAUTH);
    1053       memset(answer, '\0', 512);
     1053      memset(answer, 0, 512);
    10541054      MUNLOCK(answer, 512);
    10551055      SH_FREE(answer);

  • trunk/src/sh_xfer_server.c

    r539 r541  
    105105#endif
    106106#ifndef FD_ZERO
    107 #define FD_ZERO(p)      memset((char *)(p), '\0', sizeof(*(p)))
     107#define FD_ZERO(p)      memset((char *)(p), 0, sizeof(*(p)))
    108108#endif
    109109
    … …  
    17891789              clt_class = (-1);
    17901790            }
    1791           memset(buffer, '\0', sl_strlen(buffer));
     1791          memset(buffer, 0, sl_strlen(buffer));
    17921792          SH_FREE(buffer);
    17931793         
    … …  
    18471847#endif
    18481848         
    1849           memset(buffer, '\0', sl_strlen(buffer));
     1849          memset(buffer, 0, sl_strlen(buffer));
    18501850          SH_FREE(buffer);
    18511851         
    … …  
    31043104  if (use_server_interface == 0) /* INADDR_ANY, listen on all interfaces */
    31053105    {
    3106       memset (&hints, '\0', sizeof (hints));
     3106      memset (&hints, 0, sizeof (hints));
    31073107      hints.ai_flags = AI_PASSIVE | AI_ADDRCONFIG;
    31083108      hints.ai_socktype = SOCK_STREAM;

  • trunk/src/sh_xfer_syslog.c

    r481 r541  
    435435
    436436#else
    437   memset (&hints, '\0', sizeof (hints));
     437  memset (&hints, 0, sizeof (hints));
    438438  hints.ai_flags = AI_PASSIVE | AI_ADDRCONFIG;
    439439  hints.ai_socktype = SOCK_DGRAM;

  • trunk/src/t-test0.c

    r481 r541  
    166166        if(size == 0) return;
    167167#if TEST > 3
    168         memset(ptr, '\0', size);
     168        memset(ptr, 0, size);
    169169#endif
    170170        for(i=0; i<size; i+=2047) {
Note: See TracChangeset for help on using the changeset viewer.