[BACK]Return to util.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mpd / src

Diff for /embedaddon/mpd/src/util.c between versions 1.1.1.1 and 1.1.1.4

version 1.1.1.1, 2012/02/21 23:32:47 version 1.1.1.4, 2021/03/17 00:39:23
Line 10 Line 10
 #include "ppp.h"  #include "ppp.h"
 #include "util.h"  #include "util.h"
 #include <termios.h>  #include <termios.h>
   #include <paths.h>
   
   #include <libutil.h>
 #include <netdb.h>  #include <netdb.h>
 #include <tcpd.h>  #include <tcpd.h>
   #include <sys/limits.h>
 #include <sys/wait.h>  #include <sys/wait.h>
 #include <sys/sysctl.h>  #include <sys/sysctl.h>
 #include <net/route.h>  #include <net/route.h>
 #include <netinet/if_ether.h>  #include <netinet/if_ether.h>
   #include <net/ethernet.h>
   #include <osreldate.h>
   
 /*  /*
  * DEFINITIONS   * DEFINITIONS
Line 32 Line 37
  * INTERNAL VARIABLES   * INTERNAL VARIABLES
  */   */
   
   #ifndef USE_NG_PRED1
 static const u_int16_t Crc16Table[256] = {  static const u_int16_t Crc16Table[256] = {
 /* 00 */    0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,  /* 00 */    0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
 /* 08 */    0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,  /* 08 */    0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
Line 66  static const u_int16_t Crc16Table[256] = { Line 72  static const u_int16_t Crc16Table[256] = {
 /* f0 */    0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,  /* f0 */    0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
 /* f8 */    0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78  /* f8 */    0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
 };  };
   #endif
   
   static FILE                   *lockFp = NULL;    static FILE                   *lockFp = NULL;
   
Line 73  static const u_int16_t Crc16Table[256] = { Line 80  static const u_int16_t Crc16Table[256] = {
  * INTERNAL FUNCTIONS   * INTERNAL FUNCTIONS
  */   */
   
   static int            UuLock(const char *devname);  
   static int            UuUnlock(const char *devname);  
   
   static void           Escape(char *line);    static void           Escape(char *line);
  static char           *ReadLine(FILE *fp, int *lineNum, char *result, int resultsize);  static char           *ReadLine(FILE *fp, int *lineNum, char *result, size_t resultsize);
   
   static char           HexVal(char c);    static char           HexVal(char c);
   
   static void           IndexConfFile(FILE *fp, struct configfile **cf);    static void           IndexConfFile(FILE *fp, struct configfile **cf);
       
  struct configfiles    *ConfigFilesIndex=NULL;  static struct configfiles     *ConfigFilesIndex=NULL;
   
 #undef isspace  #undef isspace
 #define isspace(c) (((c)==' '||(c)=='\t'||(c)=='\n'||(c)=='\r')?1:0)  #define isspace(c) (((c)==' '||(c)=='\t'||(c)=='\n'||(c)=='\r')?1:0)
Line 115  int Line 119  int
 ExecCmd(int log, const char *label, const char *fmt, ...)  ExecCmd(int log, const char *label, const char *fmt, ...)
 {  {
   int           rtn;    int           rtn;
  char          cmd[BIG_LINE_SIZE];  char          cmd[LINE_MAX];
  char          cmdn[BIG_LINE_SIZE];  char          cmdn[LINE_MAX];
   va_list       ap;    va_list       ap;
   
   va_start(ap, fmt);    va_start(ap, fmt);
Line 130  ExecCmd(int log, const char *label, const char *fmt, . Line 134  ExecCmd(int log, const char *label, const char *fmt, .
   
 /* Hide any stdout output of command */  /* Hide any stdout output of command */
   
  snprintf(cmdn + strlen(cmdn), sizeof(cmdn) - strlen(cmdn), " >/dev/null 2>&1");  snprintf(cmdn + strlen(cmdn), sizeof(cmdn) - strlen(cmdn), " >%s 2>&1", _PATH_DEVNULL);
   
 /* Do command */  /* Do command */
   
Line 150  int Line 154  int
 ExecCmdNosh(int log, const char *label, const char *fmt, ...)  ExecCmdNosh(int log, const char *label, const char *fmt, ...)
 {  {
     int         rtn;      int         rtn;
    char        cmd[BIG_LINE_SIZE];    char        cmd[LINE_MAX];
     char        *cmdp = &(cmd[0]);      char        *cmdp = &(cmd[0]);
     char        *argv[256];      char        *argv[256];
     char        **arg;      char        **arg;
Line 202  ExecCmdNosh(int log, const char *label, const char *fm Line 206  ExecCmdNosh(int log, const char *label, const char *fm
                 (void)sigaction(SIGQUIT,  &quitact, NULL);                  (void)sigaction(SIGQUIT,  &quitact, NULL);
                 (void)sigprocmask(SIG_SETMASK, &oldsigblock, NULL);                  (void)sigprocmask(SIG_SETMASK, &oldsigblock, NULL);
                 close(1);                  close(1);
                open("/dev/null", O_WRONLY);                open(_PATH_DEVNULL, O_WRONLY);
                 close(2);                  close(2);
                open("/dev/null", O_WRONLY);                open(_PATH_DEVNULL, O_WRONLY);
                 execv(argv[0], argv);                  execv(argv[0], argv);
                 exit(127);                  exit(127);
         default:                        /* parent */          default:                        /* parent */
Line 375  Escape(char *line) Line 379  Escape(char *line)
   
 int  int
 ReadFile(const char *filename, const char *target,  ReadFile(const char *filename, const char *target,
        int (*func)(Context ctx, int ac, char *av[], const char *file, int line), Context ctx)        int (*func)(Context ctx, int ac, const char *const av[], const char *file, int line), Context ctx)
 {  {
   FILE  *fp;    FILE  *fp;
   int   ac;    int   ac;
Line 388  ReadFile(const char *filename, const char *target, Line 392  ReadFile(const char *filename, const char *target,
 /* Open file */  /* Open file */
   
   if ((fp = OpenConfFile(filename, &cf)) == NULL)    if ((fp = OpenConfFile(filename, &cf)) == NULL)
    return(-1);    return(-2);
   
 /* Find label */  /* Find label */
   
Line 406  ReadFile(const char *filename, const char *target, Line 410  ReadFile(const char *filename, const char *target,
       break;        break;
     }      }
     ac = ParseLine(line, av, sizeof(av) / sizeof(*av), 0);      ac = ParseLine(line, av, sizeof(av) / sizeof(*av), 0);
    (*func)(ctx, ac, av, filename, lineNum);    (*func)(ctx, ac, (const char *const *)av, filename, lineNum);
   }    }
   
 /* Done */  /* Done */
Line 555  OpenConfFile(const char *name, struct configfile **cf) Line 559  OpenConfFile(const char *name, struct configfile **cf)
 char *  char *
 ReadFullLine(FILE *fp, int *lineNum, char *result, int resultsize)  ReadFullLine(FILE *fp, int *lineNum, char *result, int resultsize)
 {  {
  int           len, linelen, resultlinesize, continuation;  int           len, resultlinesize, continuation;
   unsigned        linelen;
   char          line[BIG_LINE_SIZE];    char          line[BIG_LINE_SIZE];
   char          real_line[BIG_LINE_SIZE];    char          real_line[BIG_LINE_SIZE];
   char          *resultline;    char          *resultline;
Line 623  ReadFullLine(FILE *fp, int *lineNum, char *result, int Line 628  ReadFullLine(FILE *fp, int *lineNum, char *result, int
  */   */
   
 static char *  static char *
ReadLine(FILE *fp, int *lineNum, char *result, int resultsize)ReadLine(FILE *fp, int *lineNum, char *result, size_t resultsize)
 {  {
   int           empty;    int           empty;
   char          *s;    char          *s;
Line 666  ReadLine(FILE *fp, int *lineNum, char *result, int res Line 671  ReadLine(FILE *fp, int *lineNum, char *result, int res
     return(result);      return(result);
 }  }
   
   #ifdef PHYSTYPE_MODEM
 /*  /*
  * OpenSerialDevice()   * OpenSerialDevice()
  *   *
Line 737  ExclusiveOpenDevice(const char *label, const char *pat Line 743  ExclusiveOpenDevice(const char *label, const char *pat
   
 /* Lock device UUCP style, if it resides in /dev */  /* Lock device UUCP style, if it resides in /dev */
   
  if (!strncmp(pathname, "/dev/", 5))  if (!strncmp(pathname, _PATH_DEV, 5))
   {    {
       int res;
     ttyname = pathname + 5;      ttyname = pathname + 5;
    if (UuLock(ttyname) < 0)    if ((res = uu_lock(ttyname)) != UU_LOCK_OK) {
    {      Log(LG_ERR, ("[%s] uu_lock(%s): %s", label, ttyname, uu_lockerr(res)));
      Log(LG_ERR, ("[%s] can't lock device %s", label, ttyname)); 
       return(-1);        return(-1);
     }      }
     locked = TRUE;      locked = TRUE;
Line 757  ExclusiveOpenDevice(const char *label, const char *pat Line 763  ExclusiveOpenDevice(const char *label, const char *pat
     {      {
       Perror("[%s] can't open %s", label, pathname);        Perror("[%s] can't open %s", label, pathname);
       if (locked)        if (locked)
        UuUnlock(ttyname);        uu_unlock(ttyname);
       return(-1);        return(-1);
     }      }
   
Line 768  ExclusiveOpenDevice(const char *label, const char *pat Line 774  ExclusiveOpenDevice(const char *label, const char *pat
     Log(LG_ERR, ("[%s] can't open %s after %d secs",      Log(LG_ERR, ("[%s] can't open %s after %d secs",
       label, pathname, MAX_OPEN_DELAY));        label, pathname, MAX_OPEN_DELAY));
     if (locked)      if (locked)
      UuUnlock(ttyname);      uu_unlock(ttyname);
     return(-1);      return(-1);
   }    }
   (void) fcntl(fd, F_SETFD, 1);    (void) fcntl(fd, F_SETFD, 1);
Line 810  ExclusiveCloseDevice(const char *label, int fd, const  Line 816  ExclusiveCloseDevice(const char *label, int fd, const 
   
 /* Remove lock */  /* Remove lock */
   
  if (!strncmp(pathname, "/dev/", 5))  if (!strncmp(pathname, _PATH_DEV, 5))
   {    {
     ttyname = pathname + 5;      ttyname = pathname + 5;
    if (UuUnlock(ttyname) < 0)    if (uu_unlock(ttyname) < 0)
       Perror("[%s] can't unlock %s", label, ttyname);        Perror("[%s] can't unlock %s", label, ttyname);
   }    }
 }  }
   #endif /* PHYSTYPE_MODEM */
   
 /*  
  * UuLock()  
  *  
  * Try to atomically create lockfile. Returns negative if failed.  
  */  
   
 static int  
 UuLock(const char *ttyname)  
 {  
   int   fd, pid;  
   char  tbuf[sizeof(PATH_LOCKFILENAME) + MAX_FILENAME];  
   char  pid_buf[64];  
   
   snprintf(tbuf, sizeof(tbuf), PATH_LOCKFILENAME, ttyname);  
   if ((fd = open(tbuf, O_RDWR|O_CREAT|O_EXCL, 0664)) < 0)  
   {  
   
   /* File is already locked; Check to see if the process  
    * holding the lock still exists */  
   
     if ((fd = open(tbuf, O_RDWR, 0)) < 0)  
     {  
       Perror("%s: open(%s)", __FUNCTION__, tbuf);  
       return(-1);  
     }  
   
     if (read(fd, pid_buf, sizeof(pid_buf)) <= 0)  
     {  
       (void)close(fd);  
       Perror("%s: read", __FUNCTION__);  
       return(-1);  
     }  
   
     pid = atoi(pid_buf);  
   
     if (kill(pid, 0) == 0 || errno != ESRCH)  
     {  
       (void)close(fd);  /* process is still running */  
       return(-1);  
     }  
   
   /* The process that locked the file isn't running, so we'll lock it */  
   
     if (lseek(fd, (off_t) 0, L_SET) < 0)  
     {  
       (void)close(fd);  
       Perror("%s: lseek", __FUNCTION__);  
       return(-1);  
     }  
   }  
   
 /* Finish the locking process */  
   
   sprintf(pid_buf, "%10u\n", (int) gPid);  
   if (write(fd, pid_buf, strlen(pid_buf)) != strlen(pid_buf))  
   {  
     (void)close(fd);  
     (void)unlink(tbuf);  
     Perror("%s: write", __FUNCTION__);  
     return(-1);  
   }  
   (void)close(fd);  
   return(0);  
 }  
   
 /*  /*
  * UuUnlock()  
  */  
   
 static int  
 UuUnlock(const char *ttyname)  
 {  
   char  tbuf[sizeof(PATH_LOCKFILENAME) + MAX_FILENAME];  
   
   (void) sprintf(tbuf, PATH_LOCKFILENAME, ttyname);  
   return(unlink(tbuf));  
 }  
   
 /*  
  * GenerateMagic()   * GenerateMagic()
  *   *
  * Generate random number which will be used as magic number.   * Generate random number which will be used as magic number.
Line 925  GenerateMagic(void) Line 855  GenerateMagic(void)
 int  int
 PIDCheck(const char *filename, int killem)  PIDCheck(const char *filename, int killem)
 {  {
  int   fd = -1, n_tries;  int   n_tries;
   struct pidfh *pfh = NULL;
   
 /* Sanity */  /* Sanity */
   
Line 933  PIDCheck(const char *filename, int killem) Line 864  PIDCheck(const char *filename, int killem)
   
 /* Atomically open and lock file */  /* Atomically open and lock file */
   
  for (n_tries = 0;  for (n_tries = 0; n_tries < MAX_LOCK_ATTEMPTS; n_tries++)
    n_tries < MAX_LOCK_ATTEMPTS 
      && (fd = open(filename, O_RDWR|O_CREAT|O_EXLOCK|O_NONBLOCK, 0644)) < 0; 
    n_tries++) 
   {    {
    int         nscan, old_pid;    pid_t old_pid;
    FILE    *fp; 
   
  /* Abort on any unexpected errors */    pfh = pidfile_open(filename, 0644, &old_pid);
    if (pfh == NULL) {
    if (errno != EAGAIN)        if (errno == EEXIST) {
    {            if (!killem) {
      Perror("%s: open(%s)", __FUNCTION__, filename);                Log(LG_ERR, ("already running as process %d", old_pid));
      return(-1);                return(-1);
             }
             if (kill(old_pid, SIGTERM) < 0)
                 switch (errno) {
                 case ESRCH:
                     Log(LG_ERR, ("process %d no longer exists", old_pid));
                     break;
                 default:
                     Perror("%s: kill(%d)", __FUNCTION__, old_pid);
                     return(-1);
                 }
             /* Wait and try again */
             Log(LG_ERR, ("waiting for process %d to die...", old_pid));
             sleep(1);
         } else {
             Perror("cannot open pid file");
             return(-1);
         }
     } else {
         pidfile_write(pfh);
         break;
     }      }
   
   /* We're already running ... see who it is */  
   
     if ((fp = fopen(filename, "r")) == NULL)  
     {  
       Perror("%s: fopen(%s)", __FUNCTION__, filename);  
       return(-1);  
     }  
   
   /* If there's a PID in there, sniff it out */  
   
     nscan = fscanf(fp, "%d", &old_pid);  
     fclose(fp);  
     if (nscan != 1)  
     {  
       Log(LG_ERR, ("%s: contents mangled", filename));  
       return(-1);  
     }  
   
   /* Maybe kill the other guy */  
   
     if (!killem)  
     {  
       Log(LG_ERR, ("already running as process %d", old_pid));  
       return(-1);  
     }  
     if (kill(old_pid, SIGTERM) < 0)  
       switch (errno)  
       {  
         case ESRCH:  
           Log(LG_ERR, ("process %d no longer exists", old_pid));  
           break;  
         default:  
           Perror("%s: kill(%d)", __FUNCTION__, old_pid);  
           return(-1);  
       }  
   
   /* Wait and try again */  
   
     Log(LG_ERR, ("waiting for process %d to die...", old_pid));  
     sleep(1);  
   }    }
   if (n_tries == MAX_LOCK_ATTEMPTS)    if (n_tries == MAX_LOCK_ATTEMPTS)
   {    {
     Log(LG_ERR, ("can't lock %s after %d attempts", filename, n_tries));      Log(LG_ERR, ("can't lock %s after %d attempts", filename, n_tries));
     return(-1);      return(-1);
   }    }
   
 /* Close on exec */  
   
   (void) fcntl(fd, F_SETFD, 1);  
   
 /* Create a stream on top of file descriptor */  
   
   if ((lockFp = fdopen(fd, "r+")) == NULL)  
   {  
     Perror("%s: fdopen", __FUNCTION__);  
     return(-1);  
   }  
   setbuf(lockFp, NULL);  
   
 /* Write my PID in there */  
   
   rewind(lockFp);  
   fprintf(lockFp, "%u\n", (u_int) gPid);  
   fflush(lockFp);  
   (void) ftruncate(fileno(lockFp), ftell(lockFp));  
   return(0);    return(0);
 }  }
   
Line 1093  TcpGetListenPort(struct u_addr *addr, in_port_t port,  Line 979  TcpGetListenPort(struct u_addr *addr, in_port_t port, 
   
 /* Make socket available for connections  */  /* Make socket available for connections  */
   
  if (listen(sock, 2) < 0)  if (listen(sock, -1) < 0)
   {    {
     Perror("%s: listen", __FUNCTION__);      Perror("%s: listen", __FUNCTION__);
     (void) close(sock);      (void) close(sock);
Line 1166  ShowMesg(int log, const char *pref, const char *buf, i Line 1052  ShowMesg(int log, const char *pref, const char *buf, i
   
   if (len > 0)    if (len > 0)
   {    {
    if (len > sizeof(mesg) - 1)    if (len > (int)(sizeof(mesg) - 1))
       len = sizeof(mesg) - 1;        len = sizeof(mesg) - 1;
     memcpy(mesg, buf, len);      memcpy(mesg, buf, len);
     mesg[len] = 0;      mesg[len] = 0;
Line 1186  Bin2Hex(const unsigned char *bin, size_t len) Line 1072  Bin2Hex(const unsigned char *bin, size_t len)
   size_t        i, j;    size_t        i, j;
   char          *buf;    char          *buf;
       
  buf = Malloc(MB_UTIL, len * 2 + 1);  if (len > 0) {
  for (i = j = 0; i < len; i++) {    buf = Malloc(MB_UTIL, len * 2 + 1);
    buf[j++] = hexconvtab[bin[i] >> 4];    for (i = j = 0; i < len; i++) {
    buf[j++] = hexconvtab[bin[i] & 15];      buf[j++] = hexconvtab[bin[i] >> 4];
       buf[j++] = hexconvtab[bin[i] & 15];
     }
     buf[j] = 0;
   } else {
     buf = Malloc(MB_UTIL, 3);
     buf[0] = '0';
     buf[1] = '0';
     buf[2] = 0;
   }    }
   buf[j] = 0;  
   return buf;    return buf;
 }  }
   
Line 1202  Bin2Hex(const unsigned char *bin, size_t len) Line 1095  Bin2Hex(const unsigned char *bin, size_t len)
 u_char *  u_char *
 Hex2Bin(char *hexstr)  Hex2Bin(char *hexstr)
 {  {
  int           i;  unsigned      i;
   u_char        *binval;    u_char        *binval;
   
   binval = Malloc(MB_UTIL, strlen(hexstr) / 2);    binval = Malloc(MB_UTIL, strlen(hexstr) / 2);
Line 1228  HexVal(char c) Line 1121  HexVal(char c)
   }    }
 }  }
   
   #ifndef USE_NG_PRED1
 /*  /*
  * Crc16()   * Crc16()
  *   *
Line 1242  Crc16(u_short crc, u_char *cp, int len) Line 1136  Crc16(u_short crc, u_char *cp, int len)
     crc = (crc >> 8) ^ Crc16Table[(crc ^ *cp++) & 0xff];      crc = (crc >> 8) ^ Crc16Table[(crc ^ *cp++) & 0xff];
   return(crc);    return(crc);
 }  }
   #endif
   
 /*  /*
  * GetAnyIpAddress()   * GetAnyIpAddress()
Line 1283  GetAnyIpAddress(struct u_addr *ipaddr, const char *ifn Line 1178  GetAnyIpAddress(struct u_addr *ipaddr, const char *ifn
             close(s);              close(s);
             return(-1);              return(-1);
         }          }
        ipa = ((struct sockaddr_in *)&ifreq.ifr_ifru.ifru_addr)->sin_addr;        ipa = ((struct sockaddr_in *)(void *)&ifreq.ifr_ifru.ifru_addr)->sin_addr;
         if ((ntohl(ipa.s_addr)>>24) == 127)          if ((ntohl(ipa.s_addr)>>24) == 127)
             ipa.s_addr = 0;     /* We don't like 127.0.0.1 */              ipa.s_addr = 0;     /* We don't like 127.0.0.1 */
     }      }
Line 1303  GetAnyIpAddress(struct u_addr *ipaddr, const char *ifn Line 1198  GetAnyIpAddress(struct u_addr *ipaddr, const char *ifn
         }          }
                   
         /* if used size is too close to allocated size retry with a larger buffer */          /* if used size is too close to allocated size retry with a larger buffer */
        if (ifc.ifc_len + 128 < buffsize)        if ((unsigned)ifc.ifc_len + 128 < buffsize)
           break;            break;
                   
          Freee(ifs);           Freee(ifs);
Line 1403  GetEther(struct u_addr *addr, struct sockaddr_dl *hwad Line 1298  GetEther(struct u_addr *addr, struct sockaddr_dl *hwad
         }          }
                     
         /* if used size is too close to allocated size retry with a larger buffer */          /* if used size is too close to allocated size retry with a larger buffer */
        if (ifc.ifc_len + 128 < buffsize)        if ((unsigned)ifc.ifc_len + 128 < buffsize)
             break;              break;
                     
         Freee(ifs);          Freee(ifs);
Line 1434  GetEther(struct u_addr *addr, struct sockaddr_dl *hwad Line 1329  GetEther(struct u_addr *addr, struct sockaddr_dl *hwad
       ifreq.ifr_addr = ifr->ifr_addr;        ifreq.ifr_addr = ifr->ifr_addr;
   
       /* Check that the interface is up, and not point-to-point or loopback */        /* Check that the interface is up, and not point-to-point or loopback */
      if (ioctl(s, SIOCGIFFLAGS, &ifreq) < 0)      if (ioctl(s, SIOCGIFFLAGS, &ifreq) < 0) {
         Log(LG_IFACE2, ("ioctl(SIOCGIFFLAGS, %s): %d", ifr->ifr_name, errno));
         continue;          continue;
         }
       if ((ifreq.ifr_flags &        if ((ifreq.ifr_flags &
           (IFF_UP|IFF_BROADCAST|IFF_POINTOPOINT|IFF_LOOPBACK|IFF_NOARP))            (IFF_UP|IFF_BROADCAST|IFF_POINTOPOINT|IFF_LOOPBACK|IFF_NOARP))
           != (IFF_UP|IFF_BROADCAST))            != (IFF_UP|IFF_BROADCAST))
Line 1514  GetPeerEther(struct u_addr *addr, struct sockaddr_dl * Line 1411  GetPeerEther(struct u_addr *addr, struct sockaddr_dl *
         mib[5] = 0;          mib[5] = 0;
 #endif  #endif
         if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) {          if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) {
                Log(LG_ERR, ("route-sysctl-estimate"));                Perror("route-sysctl-estimate");
                 return (0);                  return (0);
         }          }
         if (needed == 0)        /* empty table */          if (needed == 0)        /* empty table */
Line 1536  GetPeerEther(struct u_addr *addr, struct sockaddr_dl * Line 1433  GetPeerEther(struct u_addr *addr, struct sockaddr_dl *
         }          }
         lim = buf + needed;          lim = buf + needed;
         for (next = buf; next < lim; next += rtm->rtm_msglen) {          for (next = buf; next < lim; next += rtm->rtm_msglen) {
                rtm = (struct rt_msghdr *)next;                rtm = (struct rt_msghdr *)(void *)next;
                 sin2 = (struct sockaddr_inarp *)(rtm + 1);                  sin2 = (struct sockaddr_inarp *)(rtm + 1);
                 if (addr->u.ip4.s_addr == sin2->sin_addr.s_addr) {                  if (addr->u.ip4.s_addr == sin2->sin_addr.s_addr) {
                        sdl = (struct sockaddr_dl *)((char *)sin2 + SA_SIZE(sin2));                        sdl = (struct sockaddr_dl *)(void *)((char *)sin2 + SA_SIZE(sin2));
                         memcpy(hwaddr, sdl, sdl->sdl_len);                          memcpy(hwaddr, sdl, sdl->sdl_len);
                         found_entry = 1;                          found_entry = 1;
                         break;                          break;
Line 1556  void Line 1453  void
 ppp_util_ascify(char *buf, size_t bsiz, const char *data, size_t len)  ppp_util_ascify(char *buf, size_t bsiz, const char *data, size_t len)
 {  {
         char *bp;          char *bp;
        int i;        unsigned i;
   
         for (bp = buf, i = 0; i < len; i++) {          for (bp = buf, i = 0; i < len; i++) {
                 const char ch = (char)data[i];                  const char ch = (char)data[i];
Line 1594  ppp_util_ascify(char *buf, size_t bsiz, const char *da Line 1491  ppp_util_ascify(char *buf, size_t bsiz, const char *da
         *bp = '\0';          *bp = '\0';
 }  }
   
   #ifndef HAVE_NTOA_R
   /*
    * Convert a binary representation of an ethernet address to an ASCII string.
    */
   char *
   ether_ntoa_r(const struct ether_addr *n, char *a)
   {
           int i;
   
           i = sprintf(a, "%02x:%02x:%02x:%02x:%02x:%02x", n->octet[0],
               n->octet[1], n->octet[2], n->octet[3], n->octet[4], n->octet[5]);
           if (i < 17)
                   return (NULL);
           return (a);
   }
   #endif
   
   int
   IfaceSetFlag(const char *ifname, int value)
   {
           struct ifreq            my_ifr;
           int s;
           int flags;
   
           /* Get socket */
           if ((s = socket(PF_LOCAL, SOCK_DGRAM, 0)) < 0) {
               Perror("Can't get socket to set flags");
               return(-1);
           }
   
           memset(&my_ifr, 0, sizeof(my_ifr));
           (void) strlcpy(my_ifr.ifr_name, ifname, sizeof(my_ifr.ifr_name));
   
           if (ioctl(s, SIOCGIFFLAGS, (caddr_t)&my_ifr) < 0) {
                   Perror("ioctl (SIOCGIFFLAGS)");
                   close(s);
                   return (-1);
           }
           flags = (my_ifr.ifr_flags & 0xffff) | (my_ifr.ifr_flagshigh << 16);
   
           if (value < 0) {
                   value = -value;
                   flags &= ~value;
           } else
                   flags |= value;
           my_ifr.ifr_flags = flags & 0xffff;
           my_ifr.ifr_flagshigh = flags >> 16;
           if (ioctl(s, SIOCSIFFLAGS, (caddr_t)&my_ifr) < 0) {
                   Perror("ioctl (SIOCSIFFLAGS)");
                   close(s);
                   return (-1);
           }
           close(s);
           return (0);
   }
Removed from v.1.1.1.1  
changed lines
  Added in v.1.1.1.4

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>