Changeset 235 for trunk/src


Ignore:
Timestamp:
Jul 11, 2009, 2:19:07 PM (15 years ago)
Author:
katerina
Message:

Fix for potential deadlock when calling external programm (ticket #155).

Location:
trunk/src
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/sh_entropy.c

    r227 r235  
    567567  if (source->pid == (pid_t) 0)
    568568    {
     569      int val_return;
    569570
    570571      /* child - make read side of the pipe stdout
    571572       */
    572       if (retry_aud_dup2(FIL__, __LINE__,
    573                          pipedes[STDOUT_FILENO], STDOUT_FILENO) < 0)
    574         aud__exit(FIL__, __LINE__, EXIT_FAILURE);
     573      do {
     574        val_return = dup2 (pipedes[STDOUT_FILENO], STDOUT_FILENO);
     575      } while (val_return < 0 && errno == EINTR);
     576
     577      if (val_return < 0)
     578        _exit(EXIT_FAILURE);
    575579     
    576580      /* close the pipe descriptors
    … …  
    602606 
    603607          if (NULL != tempres) {
    604             i = aud_setgid(FIL__, __LINE__, tempres->pw_gid);
     608            i = setgid(tempres->pw_gid);
    605609            if (i == 0)
    606610              i = sh_unix_initgroups(DEFAULT_IDENT ,tempres->pw_gid);
    607611            if (i == 0)
    608               i = aud_setuid(FIL__, __LINE__, tempres->pw_uid);
     612              i = setuid(tempres->pw_uid);
    609613            /* make sure we cannot get root again
    610614             */
    611             if ((tempres->pw_uid != 0) && (aud_setuid(FIL__, __LINE__, 0) >= 0))
     615            if ((tempres->pw_uid != 0) &&
     616                (setuid(0) >= 0))
    612617              i = -1;
    613618          } else {
    … …  
    622627       */
    623628      if (i == -1) {
    624         aud__exit(FIL__, __LINE__, EXIT_FAILURE);
     629        _exit(EXIT_FAILURE);
    625630      }
    626631     
    … …  
    629634     
    630635          /* exec the program */
    631           retry_aud_execve (FIL__, __LINE__, _("/bin/sh"), arg, envp);
     636          do {
     637            val_return = execve (_("/bin/sh"), arg, envp);
     638          } while (val_return < 0 && errno == EINTR);
    632639        }
    633640
    634641      /* failed
    635642       */
    636       aud__exit(FIL__, __LINE__, EXIT_FAILURE);
     643      _exit(EXIT_FAILURE);
    637644    }
    638645

  • trunk/src/sh_extern.c

    r227 r235  
    185185   * --  check whether the checksum is correct; with linux emulate fdexec
    186186   */
    187 #if !defined(__linux__) && !defined(SL_DEBUG)
     187#if ( !defined(__linux__) || ( defined(__linux__) && defined(HAVE_PTHREAD)) ) && !defined(SL_DEBUG)
    188188  if (task->checksum[0]  != '\0')
    189189    {
    … …  
    256256      if (S_TRUE == task->fork_twice)
    257257        {
    258           task->pid = aud_fork(FIL__, __LINE__);
     258          task->pid = fork();
    259259
    260260          if (task->pid == (pid_t) - 1)
    261261            {
    262               aud__exit (FIL__, __LINE__, EXIT_FAILURE);
     262              _exit (EXIT_FAILURE);
    263263            }
    264264        }
    … …  
    266266      if (task->pid == (pid_t) 0)
    267267        {
     268          int val_return;
     269
    268270          PDBGC_OPEN;
    269271          PDBGC(1);
    … …  
    274276          if (task->rw == 'w')
    275277            {
    276               if (retry_aud_dup2(FIL__, __LINE__,
    277                                  pipedes[STDIN_FILENO], STDIN_FILENO) < 0)
    278                 aud__exit(FIL__, __LINE__,EXIT_FAILURE);
     278              do {
     279                val_return = dup2 (pipedes[STDIN_FILENO], STDIN_FILENO);
     280              } while (val_return < 0 && errno == EINTR);
     281
     282              if (val_return < 0)
     283                _exit(EXIT_FAILURE);
    279284            }
    280285          else
    281286            {
    282               if (retry_aud_dup2(FIL__, __LINE__,
    283                                  pipedes[STDOUT_FILENO], STDOUT_FILENO) < 0)
    284                 aud__exit(FIL__, __LINE__,EXIT_FAILURE);
     287              do {
     288                val_return = dup2 (pipedes[STDOUT_FILENO], STDOUT_FILENO);
     289              } while (val_return < 0 && errno == EINTR);
     290
     291              if (val_return < 0)
     292                _exit(EXIT_FAILURE);
    285293            }
    286294          PDBGC(2);
    … …  
    308316              memset(skey, 0, sizeof(sh_key_t));
    309317
    310               (void) aud_setgid(FIL__, __LINE__,(gid_t) task->run_user_gid);
    311               (void) aud_setuid(FIL__, __LINE__,(uid_t) task->run_user_uid);
     318              (void) setgid((gid_t) task->run_user_gid);
     319              (void) setuid((uid_t) task->run_user_uid);
    312320              /* make sure we cannot get root again
    313321               */
    314               if (aud_setuid(FIL__, __LINE__,0) >= 0)
    315                 aud__exit(FIL__, __LINE__,EXIT_FAILURE);
     322              if (setuid(0) >= 0)
     323                _exit(EXIT_FAILURE);
    316324            }
    317325         
    … …  
    332340            {
    333341              PDBGC_S("r");
    334               (void) retry_aud_dup2 (FIL__, __LINE__,
    335                                      STDOUT_FILENO, STDERR_FILENO);
     342              do {
     343                val_return = dup2 (STDOUT_FILENO, STDERR_FILENO);
     344              } while (val_return < 0 && errno == EINTR);
     345
    336346              (void) fcntl  (STDIN_FILENO, F_SETFD, FD_CLOEXEC);
    337347              /*
    … …  
    347357           * --  emulate an fdexec with checksum testing
    348358           */
     359
     360#if !defined(HAVE_PTHREAD)
    349361          if (task->checksum[0]  != '\0')
     362#endif
    350363            {
    351364              PDBGC_S("fexecve");
    352365              if (task->com_fd != (-1))
    353366                {
    354                   pfd = retry_aud_dup(FIL__, __LINE__, task->com_fd);
     367                  do {
     368                    val_return = dup (task->com_fd);
     369                  } while (val_return < 0 && errno == EINTR);
     370                  pfd = val_return;
    355371                  if (pfd < 0)
    356372                    {
    357                       PDBGC_S("fexecve: dup2 failed");
    358                       aud__exit(FIL__, __LINE__, EXIT_FAILURE);
     373                      PDBGC_S("fexecve: dup failed");
     374                      _exit(EXIT_FAILURE);
    359375                    }
    360376                }
     377#if !defined(HAVE_PTHREAD)
    361378              else
    362379                {
    … …  
    372389                    {
    373390                      PDBGC_S("fexecve: checksum mismatch");
    374                       aud__exit(FIL__, __LINE__, EXIT_FAILURE);
     391                      _exit(EXIT_FAILURE);
    375392                    }
    376393                  pfd = get_the_fd(fd);
    377394                }
     395#endif
    378396             
    379397              PDBGC(5);
    … …  
    384402                  PDBGC_CLOSE;
    385403                  fcntl  (pfd, F_SETFD, FD_CLOEXEC);
    386                   retry_aud_execve (FIL__, __LINE__,
    387                                     pname,
    388                                     (task->argc == 0) ? NULL : task->argv,
    389                                     (task->envc == 0) ? NULL : task->envv
    390                                     );
     404                  do {
     405                    val_return = execve (pname,
     406                                         (task->argc == 0) ? NULL : task->argv,
     407                                         (task->envc == 0) ? NULL : task->envv
     408                                         );
     409                  } while (val_return < 0 && errno == EINTR);
    391410                 
    392411                  errnum = errno;
    … …  
    398417                  /* failed
    399418                   */
    400                   aud__exit(FIL__, __LINE__, EXIT_FAILURE);
     419                  _exit(EXIT_FAILURE);
    401420              }
    402421              PDBGC_S("fexecve: not working");
    … …  
    419438              PDBGC(5);
    420439              PDBGC_CLOSE;
    421               (void) retry_aud_execve (FIL__, __LINE__,
    422                                        task->command,
    423                                        (task->argc == 0) ? argp : task->argv,
    424                                        (task->envc == 0) ? envp : task->envv
    425                                        );
     440              do {
     441                val_return = execve (task->command,
     442                                     (task->argc == 0) ? argp : task->argv,
     443                                     (task->envc == 0) ? envp : task->envv
     444                                     );
     445              } while (val_return < 0 && errno == EINTR);
    426446            }
    427447          errnum = errno;
    … …  
    433453          /* failed
    434454           */
    435           aud__exit(FIL__, __LINE__, EXIT_FAILURE);
     455          _exit(EXIT_FAILURE);
    436456        }
    437457      /*
    … …  
    440460      if (S_TRUE == task->fork_twice)
    441461        {
    442           aud__exit (FIL__, __LINE__, 0);
     462          _exit (0);
    443463        }
    444464    }

  • trunk/src/sh_port2proc.c

    r206 r235  
    304304  return 0;
    305305}
     306
     307void sh_port2proc_finish()
     308{
     309  /* Delete old socket list
     310   */
     311  del_sock_all();
     312  return;
     313}
     314
    306315
    307316#include <sys/socket.h>
    … …  
    866875}
    867876
     877void sh_port2proc_finish()
     878{
     879  return;
     880}
     881
    868882#else /* !defined(__linux__) && !defined(__FreeBSD__) */
    869883
    … …  
    886900}
    887901
     902void sh_port2proc_finish()
     903{
     904  return;
     905}
    888906#endif
    889907

  • trunk/src/sh_portcheck.c

    r218 r235  
    140140                                 unsigned long * pid, char * user, size_t userlen);
    141141extern int sh_port2proc_prepare();
     142extern void sh_port2proc_finish();
    142143
    143144#endif
    … …  
    11011102  blacklist_udp = sh_portchk_kill_blacklist (blacklist_udp);
    11021103  blacklist_tcp = sh_portchk_kill_blacklist (blacklist_tcp);
     1104  sh_port2proc_finish();
     1105
    11031106  SH_MUTEX_UNLOCK(mutex_port_check);
    11041107  return 0;
Note: See TracChangeset for help on using the changeset viewer.