[BACK]Return to tools.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / libaitio / src

Diff for /libaitio/src/Attic/tools.c between versions 1.10 and 1.18

version 1.10, 2012/03/29 01:31:34 version 1.18, 2012/09/19 15:19:53
Line 48  SUCH DAMAGE. Line 48  SUCH DAMAGE.
   
   
 /*  /*
 * io_LTrimStr() Remove left whitespaces from text string * io_LTrimStr() - Remove left whitespaces from text string
  *   *
  * @psLine = Text string   * @psLine = Text string
  * return: 0 nothing to do; !=0 Removed bytes   * return: 0 nothing to do; !=0 Removed bytes
 */  */
 inline int  inline int
io_LTrimStr(u_char * __restrict psLine)io_LTrimStr(char * __restrict psLine)
 {  {
         int pos = 0;          int pos = 0;
        u_char *s;        char *s;
   
         if (!psLine || !*psLine)          if (!psLine || !*psLine)
                 return 0;                  return 0;
   
        for (s = psLine; isspace(*s); s++);        for (s = psLine; isspace((u_char) *s); s++);
         pos = s - psLine;          pos = s - psLine;
   
        memmove(psLine, s, (strlen((char*) psLine) - pos) + 1);        memmove(psLine, s, (strlen(psLine) - pos) + 1);
         return pos;          return pos;
 }  }
   
 /*  /*
 * io_RTrimStr() Remove right whitespaces from text string * io_RTrimStr() - Remove right whitespaces from text string
  *   *
  * @psLine = Text string   * @psLine = Text string
  * return: 0 nothing to do; !=0 Removed bytes   * return: 0 nothing to do; !=0 Removed bytes
 */  */
 inline int  inline int
io_RTrimStr(u_char * __restrict psLine)io_RTrimStr(char * __restrict psLine)
 {  {
        u_char *t, *pos;        char *t, *pos;
   
         if (!psLine || !*psLine)          if (!psLine || !*psLine)
                 return 0;                  return 0;
   
        pos = psLine + strlen((char*) psLine);        pos = psLine + strlen(psLine);
        for (t = pos - 1; t > psLine && isspace(*t); t--);        for (t = pos - 1; t > psLine && isspace((u_char) *t); t--);
         *++t = 0;          *++t = 0;
   
         return pos - t;          return pos - t;
 }  }
   
 /*  /*
 * io_TrimStr() Remove left and right whitespaces from text string * io_TrimStr() - Remove left and right whitespaces from text string
  *   *
  * @psLine = Text string   * @psLine = Text string
  * return: 0 nothing to do; !=0 Removed bytes   * return: 0 nothing to do; !=0 Removed bytes
 */  */
 inline int  inline int
io_TrimStr(u_char * __restrict psLine)io_TrimStr(char * __restrict psLine)
 {  {
         int ret = 0;          int ret = 0;
   
Line 108  io_TrimStr(u_char * __restrict psLine) Line 108  io_TrimStr(u_char * __restrict psLine)
 }  }
   
 /*  /*
 * io_UnquotStr() Remove quots from input text string  * io_UnquotStr() - Remove quots from input text string 
  *   *
  * @psLine = Text string   * @psLine = Text string
  * return: 0 nothing to do; 1 successful unquoted string   * return: 0 nothing to do; 1 successful unquoted string
 */  */
 inline int  inline int
io_UnquotStr(u_char * __restrict psLine)io_UnquotStr(char * __restrict psLine)
 {  {
         char *pos, *str = NULL;          char *pos, *str = NULL;
         int flg;          int flg;
Line 122  io_UnquotStr(u_char * __restrict psLine) Line 122  io_UnquotStr(u_char * __restrict psLine)
         if (!psLine)          if (!psLine)
                 return 0;                  return 0;
   
        switch (*psLine) {        if (*psLine == '"' || *psLine == '\'') {
                case '`':                str = io_strdup(psLine + 1);
                case '"':                for (pos = str, flg = 0; *pos; flg = ('\\' == *pos), pos++) {
                case '\'':                        if (!flg && *pos == *psLine) {
                        str = strdup((char*) psLine + 1);                                *pos = 0;
                        for (pos = str, flg = 0; *pos; flg = ('\\' == *pos), pos++) {                                strlcpy(psLine, str, strlen(psLine) + 1);
                                if (!flg && *pos == *psLine) {                                break;
                                        *pos = 0; 
                                        strlcpy((char*) psLine, str, strlen((char*) psLine) + 1); 
                                        break; 
                                } 
                         }                          }
                        free(str);                }
                        return 1;                io_free(str);
                 return 1;
         }          }
   
         return 0;          return 0;
 }  }
   
 /*  /*
 * io_Ch2Hex() Convert from Char string to Hex string * io_Ch2Hex() - Convert from Char string to Hex string
  *   *
  * @psLine = Text string   * @psLine = Text string
  * @lineLen = Length of Text string   * @lineLen = Length of Text string
 * return: NULL nothing to do or error; !=0 Allocated new converted data without term\0 (must be free) * return: NULL nothing to do or error; !=0 Allocated new converted data without term\0 (must be io_free)
 */  */
 inline u_char *  inline u_char *
 io_Ch2Hex(u_char *psLine, int lineLen)  io_Ch2Hex(u_char *psLine, int lineLen)
Line 158  io_Ch2Hex(u_char *psLine, int lineLen) Line 155  io_Ch2Hex(u_char *psLine, int lineLen)
         if (!psLine || !*psLine || !lineLen)          if (!psLine || !*psLine || !lineLen)
                 return NULL;                  return NULL;
   
        str = malloc(lineLen / 2);        str = io_malloc(lineLen / 2);
         if (!str) {          if (!str) {
                 LOGERR;                  LOGERR;
                 return NULL;                  return NULL;
Line 175  io_Ch2Hex(u_char *psLine, int lineLen) Line 172  io_Ch2Hex(u_char *psLine, int lineLen)
   
   
 /*  /*
 * io_Hex2Ch() Convert from Hex string to Char string * io_Hex2Ch() - Convert from Hex string to Char string
  *   *
  * @psLine = Text string   * @psLine = Text string
  * @lineLen = Length of Text string   * @lineLen = Length of Text string
 * return: NULL nothing to do or error; !=0 Allocated new converted string(must be free) * return: NULL nothing to do or error; !=0 Allocated new converted string(must be io_free)
 */  */
 inline char *  inline char *
 io_Hex2Ch(u_char *psLine, int lineLen)  io_Hex2Ch(u_char *psLine, int lineLen)
Line 190  io_Hex2Ch(u_char *psLine, int lineLen) Line 187  io_Hex2Ch(u_char *psLine, int lineLen)
         if (!psLine || !*psLine || !lineLen)          if (!psLine || !*psLine || !lineLen)
                 return NULL;                  return NULL;
   
        str = malloc(lineLen * 2 + 1);        str = io_malloc(lineLen * 2 + 1);
         if (!str) {          if (!str) {
                 LOGERR;                  LOGERR;
                 return NULL;                  return NULL;
Line 207  io_Hex2Ch(u_char *psLine, int lineLen) Line 204  io_Hex2Ch(u_char *psLine, int lineLen)
 }  }
   
 /*  /*
 * io_CopyEnv() Copy environment to new environment array; * io_CopyEnv() - Copy environment to new environment array;
  *   *
  * @oldenv = Environment array   * @oldenv = Environment array
 * return: NULL error; !=NULL Allocated new environment array(must be free) * return: NULL error; !=NULL Allocated new environment array(must be io_free)
 */  */
 char **  char **
 io_CopyEnv(const char **oldenv)  io_CopyEnv(const char **oldenv)
Line 229  io_CopyEnv(const char **oldenv) Line 226  io_CopyEnv(const char **oldenv)
                         num++;                          num++;
   
         /* create and copy new environment */          /* create and copy new environment */
        newenv = calloc(num + 1, sizeof(char*));        newenv = io_calloc(num + 1, sizeof(char*));
         if (!newenv) {          if (!newenv) {
                 LOGERR;                  LOGERR;
                 return NULL;                  return NULL;
Line 238  io_CopyEnv(const char **oldenv) Line 235  io_CopyEnv(const char **oldenv)
   
         for (i = 0; oldenv[i]; i++)          for (i = 0; oldenv[i]; i++)
                 if (*strchr(oldenv[i], '=')) {                  if (*strchr(oldenv[i], '=')) {
                        *el = strdup(oldenv[i]);                        *el = io_strdup(oldenv[i]);
                         el++;                          el++;
                 }                  }
         *el = NULL;          *el = NULL;
Line 247  io_CopyEnv(const char **oldenv) Line 244  io_CopyEnv(const char **oldenv)
 }  }
   
 /*  /*
 * io_ExecArgs() Build exec arguments from other array * io_ExecArgs() - Build exec arguments from other array
  *   *
  * @psProg = Program name for execute   * @psProg = Program name for execute
  * @oldarg = Arguments array   * @oldarg = Arguments array
 * return: NULL error; !=NULL Allocated execution array(must be free) * return: NULL error; !=NULL Allocated execution array(must be io_free)
 */  */
 char **  char **
 io_ExecArgs(const char *psProg, const char **oldarg)  io_ExecArgs(const char *psProg, const char **oldarg)
Line 268  io_ExecArgs(const char *psProg, const char **oldarg) Line 265  io_ExecArgs(const char *psProg, const char **oldarg)
         for (num = 0; oldarg[num]; num++);          for (num = 0; oldarg[num]; num++);
   
         /* create and copy new arguments */          /* create and copy new arguments */
        newarg = calloc(num + 2, sizeof(char*));        newarg = io_calloc(num + 2, sizeof(char*));
         if (!newarg) {          if (!newarg) {
                 LOGERR;                  LOGERR;
                 return NULL;                  return NULL;
         } else          } else
                 el = newarg;                  el = newarg;
   
        *el = strdup(psProg);        *el = io_strdup(psProg);
         el++;          el++;
   
         for (i = 0; oldarg[i]; i++, el++)          for (i = 0; oldarg[i]; i++, el++)
                *el = strdup(oldarg[i]);                *el = io_strdup(oldarg[i]);
         *el = NULL;          *el = NULL;
   
         return newarg;          return newarg;
 }  }
   
 /*  /*
 * io_FreeNullTerm() Free dynamic allocated null terminated array with strings * io_FreeNullTerm() - Free dynamic allocated null terminated array with strings
  *   *
  * @arr = Pointer to array for free   * @arr = Pointer to array for free
  * return: none   * return: none
Line 299  io_FreeNullTerm(char *** __restrict arr) Line 296  io_FreeNullTerm(char *** __restrict arr)
         if (arr && *arr) {          if (arr && *arr) {
                 a = *arr;                  a = *arr;
                 while (a && *a)                  while (a && *a)
                        free(*a++);                        io_free(*a++);
                free(*arr);                io_free(*arr);
                 *arr = NULL;                  *arr = NULL;
         }          }
 }  }
   
 /*  /*
    * io_argsNum() Parse and calculate number of arguments
    *
    * @csArgs = Input arguments line
    * @csDelim = Delimiter(s) for separate
    * return: 0 error format; -1 error:: can`t read; >0 ok, number of items
    */
   inline int
   io_argsNum(const char *csArgs, const char *csDelim)
   {
           register int res;
           char *pos;
   
           assert(csArgs);
           assert(csDelim);
           if (!csArgs || !csDelim)
                   return -1;
   
           for (res = 1, pos = (char*) csArgs; (pos = strpbrk(pos, csDelim)); res++, pos++);
           return res;
   }
   
   /*
    * io_MakeAV() Parse and make attribute/value pair
    *
    * @csArgs = Input argument line
    * @csDelim = Delimiter for separate
    * @psAttr = Output Attribute
    * @attrLen = Size of attribute array
    * @psValue = Output Value, if ==NULL this element not present value or not wanted for return
    * @valLen = Size of value array
    * return: 0 error format; -1 error:: can`t read; >0 ok, number of readed items
   */
   int
   io_MakeAV(const char * __restrict csArgs, const char *csDelim, 
                   char * __restrict psAttr, int attrLen, char * __restrict psValue, int valLen)
   {
           register int ret = 0;
           char *pos, *psBuf;
   
           if (!csArgs || !csDelim || !psAttr || !attrLen)
                   return -1;
           if (psValue && !valLen)
                   return -1;
           else
                   memset(psValue, 0, valLen);
           psBuf = io_strdup(csArgs);
           if (!psBuf) {
                   LOGERR;
                   return -1;
           }
   
           pos = strpbrk(psBuf, csDelim);
           if (pos)
                   *pos++ = 0;
           ret++;
           strlcpy(psAttr, psBuf, attrLen);
   
           if (pos && *pos) {
                   ret++;
                   if (psValue)
                           strlcpy(psValue, pos, valLen);
           }
   
           io_free(psBuf);
           return ret;
   }
   
   /*
    * io_MakeAV2() Parse and make attribute/value pair over input string
    *
    * @csArgs = Input argument line, will be modified!
    * @csDelim = Delimiter for separate
    * @psAttr = Output Attribute
    * @psValue = Output Value, if ==NULL this element not present value or not wanted for return
    * return: 0 error format; -1 error:: can`t read; >0 ok, number of readed items
   */
   int
   io_MakeAV2(char * __restrict psArgs, const char *csDelim, 
                   char ** __restrict psAttr, char ** __restrict psValue)
   {
           register int ret = 0;
           char *pos;
   
           if (!psArgs || !csDelim)
                   return -1;
   
           pos = strpbrk(psArgs, csDelim);
           if (pos) {
                   *pos++ = 0;
                   ret++;
                   if (psAttr)
                           *psAttr = psArgs;
           } else
                   return 0;
   
           if (psValue) {
                   if (pos && *pos) {
                           ret++;
                           *psValue = pos;
                   } else
                           *psValue = NULL;
           }
   
           return ret;
   }
   
   /*
  * io_Path2File() - Parse and make path/filename pair   * io_Path2File() - Parse and make path/filename pair
  *   *
  * @csArgs = Input argument line   * @csArgs = Input argument line
Line 326  io_Path2File(const char * __restrict csArgs, char * __ Line 430  io_Path2File(const char * __restrict csArgs, char * __
         if (psPath && !pathLen)          if (psPath && !pathLen)
                 return -1;                  return -1;
   
        psBuf = strdup(csArgs);        psBuf = io_strdup(csArgs);
         if (!psBuf) {          if (!psBuf) {
                 LOGERR;                  LOGERR;
                 return -1;                  return -1;
Line 336  io_Path2File(const char * __restrict csArgs, char * __ Line 440  io_Path2File(const char * __restrict csArgs, char * __
         if (!pos) {          if (!pos) {
                 strlcpy(psFile, psBuf, fileLen);                  strlcpy(psFile, psBuf, fileLen);
   
                free(psBuf);                io_free(psBuf);
                 return 1;                  return 1;
         } else          } else
                 *pos++ = 0;                  *pos++ = 0;
Line 345  io_Path2File(const char * __restrict csArgs, char * __ Line 449  io_Path2File(const char * __restrict csArgs, char * __
         if (psPath)          if (psPath)
                 strlcpy(psPath, psBuf, pathLen);                  strlcpy(psPath, psBuf, pathLen);
   
        free(psBuf);        io_free(psBuf);
         return 2;          return 2;
 }  }
   
 /*  /*
 * io_ether_ntoa() Convert ethernet address to string * io_ether_ntoa() - Convert ethernet address to string
  *   *
  * @n = ethernet address structure, like struct ether_addr   * @n = ethernet address structure, like struct ether_addr
  * @a = string   * @a = string
Line 374  io_ether_ntoa(const struct io_ether_addr *n, char * __ Line 478  io_ether_ntoa(const struct io_ether_addr *n, char * __
 }  }
   
 /*  /*
 * io_ether_aton() Convert string to ethernet address * io_ether_aton() - Convert string to ethernet address
  *   *
  * @a = string   * @a = string
  * @e = ethernet address structure, like struct ether_addr   * @e = ethernet address structure, like struct ether_addr
Line 404  io_ether_aton(const char *a, struct io_ether_addr *e) Line 508  io_ether_aton(const char *a, struct io_ether_addr *e)
 }  }
   
 /*  /*
 * io_n2port() Extract port from network structure * io_n2port() - Extract port from network structure
  *   *
  * @addr = Address   * @addr = Address
  * return: 0 not supported family type or port number   * return: 0 not supported family type or port number
Line 423  io_n2port(io_sockaddr_t * __restrict addr) Line 527  io_n2port(io_sockaddr_t * __restrict addr)
                 case AF_INET6:                  case AF_INET6:
                         return ntohs(addr->sin6.sin6_port);                          return ntohs(addr->sin6.sin6_port);
                 default:                  default:
                         io_SetErr(ESOCKTNOSUPPORT, "Unsuported address family %d",   
                                         addr->sa.sa_family);  
                         break;                          break;
         }          }
   
Line 432  io_n2port(io_sockaddr_t * __restrict addr) Line 534  io_n2port(io_sockaddr_t * __restrict addr)
 }  }
   
 /*  /*
 * io_n2addr() Extract address from network structure * io_n2addr() - Extract address from network structure
  *   *
  * @addr = Address   * @addr = Address
  * @val = Value for store string address   * @val = Value for store string address
Line 447  io_n2addr(io_sockaddr_t * __restrict addr, ait_val_t * Line 549  io_n2addr(io_sockaddr_t * __restrict addr, ait_val_t *
         if (!addr || !val)          if (!addr || !val)
                 return ret;                  return ret;
   
           AIT_INIT_VAL(val);
         switch (addr->sa.sa_family) {          switch (addr->sa.sa_family) {
                 case AF_INET:                  case AF_INET:
                         if (!inet_ntop(AF_INET, &addr->sin.sin_addr, str, INET_ADDRSTRLEN)) {                          if (!inet_ntop(AF_INET, &addr->sin.sin_addr, str, INET_ADDRSTRLEN)) {
Line 462  io_n2addr(io_sockaddr_t * __restrict addr, ait_val_t * Line 565  io_n2addr(io_sockaddr_t * __restrict addr, ait_val_t *
                         } else                          } else
                                 ret = str;                                  ret = str;
                         break;                          break;
                   case AF_LOCAL:
                           ret = addr->sun.sun_path;
                           break;
                 default:                  default:
                         io_SetErr(EPROTONOSUPPORT, "Unsuported address family %d",                           io_SetErr(EPROTONOSUPPORT, "Unsuported address family %d", 
                                         addr->sa.sa_family);                                          addr->sa.sa_family);
                         return ret;                          return ret;
         }          }
   
         if (!AIT_ISEMPTY(val))  
                 AIT_FREE_VAL(val);  
         AIT_SET_STR(val, ret);          AIT_SET_STR(val, ret);
         return (const char*) AIT_GET_STR(val);          return (const char*) AIT_GET_STR(val);
 }  }
   
 /*  /*
 * io_gethostbyname() Get host and port and make network structure * io_gethostbyname() - Get host and port and make network structure
  *   *
  * @psHost = Hostname   * @psHost = Hostname
  * @port = Port   * @port = Port
Line 485  io_n2addr(io_sockaddr_t * __restrict addr, ait_val_t * Line 589  io_n2addr(io_sockaddr_t * __restrict addr, ait_val_t *
 io_sockaddr_t *  io_sockaddr_t *
 io_gethostbyname(const char *psHost, u_short port, io_sockaddr_t * __restrict addr)  io_gethostbyname(const char *psHost, u_short port, io_sockaddr_t * __restrict addr)
 {  {
        struct hostent *host;        struct hostent *host = NULL;
   
         if (!psHost || !addr)          if (!psHost || !addr)
                 return NULL;                  return NULL;
   
        /* resolver */        if (*psHost != '/') {
        if (!addr->sa.sa_family)                /* resolver */
                host = gethostbyname(psHost);                if (!addr->sa.sa_family)
        else                        host = gethostbyname(psHost);
                host = gethostbyname2(psHost, addr->sa.sa_family);                else
        if (!host) {                        host = gethostbyname2(psHost, addr->sa.sa_family);
                io_SetErr(EINVAL, "Resolver #%d - %s", h_errno, hstrerror(h_errno));                if (!host) {
                return NULL;                        io_SetErr(EINVAL, "Resolver #%d - %s", h_errno, hstrerror(h_errno));
                         return NULL;
                 } else {
                         memset(addr, 0, sizeof(io_sockaddr_t));
                         addr->sa.sa_family = host->h_addrtype;
                 }
         } else {
                 memset(addr, 0, sizeof(io_sockaddr_t));
                 addr->sa.sa_family = AF_LOCAL;
         }          }
                   
   
        memset(addr, 0, sizeof(io_sockaddr_t));        switch (addr->sa.sa_family) {
        switch (host->h_addrtype) { 
                 case AF_INET:                  case AF_INET:
                         addr->sin.sin_len = sizeof(struct sockaddr_in);                          addr->sin.sin_len = sizeof(struct sockaddr_in);
                         addr->sin.sin_family = AF_INET;                          addr->sin.sin_family = AF_INET;
Line 514  io_gethostbyname(const char *psHost, u_short port, io_ Line 626  io_gethostbyname(const char *psHost, u_short port, io_
                         addr->sin6.sin6_port = htons(port);                          addr->sin6.sin6_port = htons(port);
                         memcpy(&addr->sin6.sin6_addr, host->h_addr, sizeof addr->sin6.sin6_addr);                          memcpy(&addr->sin6.sin6_addr, host->h_addr, sizeof addr->sin6.sin6_addr);
                         return addr;                          return addr;
                   case AF_LOCAL:
                           addr->sun.sun_len = sizeof(struct sockaddr_un);
                           addr->sun.sun_family = AF_LOCAL;
                           memset(addr->sun.sun_path, 0, sizeof addr->sun.sun_path);
                           snprintf(addr->sun.sun_path, sizeof addr->sun.sun_path, "%s-%hu", psHost, port);
                           return addr;
                 default:                  default:
                        io_SetErr(EPROTONOSUPPORT, "Unsuported address family %d",                         io_SetErr(EPROTONOSUPPORT, "Unsuported address family %d", addr->sa.sa_family);
                                        host->h_addrtype); 
                         break;                          break;
         }          }
   
         return NULL;          return NULL;
   }
   
   /*
    * io_usleep() - usleep() replacement for ELWIX
    *
    * @usec = microseconds for sleep
    * return: -1 interrupted by signal or 0 ok
    */
   inline int
   io_usleep(u_int usec)
   {
           struct timeval tv = { (time_t) (usec / 1000000), (long) (usec % 1000000) };
   
           return select(0, NULL, NULL, NULL, &tv);
 }  }
Removed from v.1.10  
changed lines
  Added in v.1.18

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