Apply timeout to Fsecure malware response. Bug 1549

[users/heiko/exim.git] / src / src / string.c

diff --git a/src/src/string.c b/src/src/string.c
index ece200bccda5a2807e05b93d1106322917bdbc19..775709dc6a4304566e9429f1d8351cffb59b4569 100644 (file)
--- a/src/src/string.c
+++ b/src/src/string.c
@@ -2,7 +2,7 @@
 *     Exim - an Internet mail transport agent    *
 *************************************************/
 
 *     Exim - an Internet mail transport agent    *
 *************************************************/
 

-/* Copyright (c) University of Cambridge 1995 - 2009 */
+/* Copyright (c) University of Cambridge 1995 - 2014 */

 /* See the file NOTICE for conditions of use and distribution. */
 
 /* Miscellaneous string-handling functions. Some are not required for
 /* See the file NOTICE for conditions of use and distribution. */
 
 /* Miscellaneous string-handling functions. Some are not required for


@@ -34,7 +34,7 @@ Returns:    0 if the string is not a textual representation of an IP address
 */
 
 int
 */
 
 int

-string_is_ip_address(uschar *s, int *maskptr)
+string_is_ip_address(const uschar *s, int *maskptr)

 {
 int i;
 int yield = 4;
 {
 int i;
 int yield = 4;


@@ -44,7 +44,7 @@ offset. */
 
 if (maskptr != NULL)
   {
 
 if (maskptr != NULL)
   {

-  uschar *ss = s + Ustrlen(s);
+  const uschar *ss = s + Ustrlen(s);

   *maskptr = 0;
   if (s != ss && isdigit(*(--ss)))
     {
   *maskptr = 0;
   if (s != ss && isdigit(*(--ss)))
     {


@@ -165,7 +165,7 @@ Returns:      pointer to the buffer
 uschar *
 string_format_size(int size, uschar *buffer)
 {
 uschar *
 string_format_size(int size, uschar *buffer)
 {

-if (size == 0) Ustrcpy(CS buffer, "     ");
+if (size == 0) Ustrcpy(buffer, "     ");

 else if (size < 1024) sprintf(CS buffer, "%5d", size);
 else if (size < 10*1024)
   sprintf(CS buffer, "%4.1fK", (double)size / 1024.0);
 else if (size < 1024) sprintf(CS buffer, "%5d", size);
 else if (size < 10*1024)
   sprintf(CS buffer, "%4.1fK", (double)size / 1024.0);


@@ -210,7 +210,6 @@ return yield;
 
 
 
 
 
 

-#ifndef COMPILE_UTILITY

 /*************************************************
 *          Interpret escape sequence             *
 *************************************************/
 /*************************************************
 *          Interpret escape sequence             *
 *************************************************/


@@ -227,6 +226,9 @@ Returns:   the value of the character escape
 int
 string_interpret_escape(uschar **pp)
 {
 int
 string_interpret_escape(uschar **pp)
 {

+#ifdef COMPILE_UTILITY
+const uschar *hex_digits= CUS"0123456789abcdef";
+#endif

 int ch;
 uschar *p = *pp;
 ch = *(++p);
 int ch;
 uschar *p = *pp;
 ch = *(++p);


@@ -262,7 +264,6 @@ else switch(ch)
 *pp = p;
 return ch;
 }
 *pp = p;
 return ch;
 }

-#endif  /* COMPILE_UTILITY */

 
 
 
 
 
 


@@ -303,7 +304,7 @@ if (nonprintcount == 0) return s;
 /* Get a new block of store guaranteed big enough to hold the
 expanded string. */
 
 /* Get a new block of store guaranteed big enough to hold the
 expanded string. */
 

-ss = store_get(length + nonprintcount * 4 + 1);
+ss = store_get(length + nonprintcount * 3 + 1);

 
 /* Copy everying, escaping non printers. */
 
 
 /* Copy everying, escaping non printers. */
 


@@ -332,6 +333,7 @@ while (*t != 0)
 *tt = 0;
 return ss;
 }
 *tt = 0;
 return ss;
 }

+#endif  /* COMPILE_UTILITY */

 
 /*************************************************
 *        Undo printing escapes in string         *
 
 /*************************************************
 *        Undo printing escapes in string         *


@@ -372,7 +374,8 @@ while (*p)
   {
   if (*p == '\\')
     {
   {
   if (*p == '\\')
     {

-    *q = string_interpret_escape(&p);
+    *q++ = string_interpret_escape(&p);
+    p++;

     }
   else
     {
     }
   else
     {


@@ -398,7 +401,6 @@ while (*p)
 
 return ss;
 }
 
 return ss;
 }

-#endif  /* COMPILE_UTILITY */

 
 
 
 
 
 


@@ -414,7 +416,7 @@ Returns:  copy of string in new store
 */
 
 uschar *
 */
 
 uschar *

-string_copy(uschar *s)
+string_copy(const uschar *s)

 {
 int len = Ustrlen(s) + 1;
 uschar *ss = store_get(len);
 {
 int len = Ustrlen(s) + 1;
 uschar *ss = store_get(len);


@@ -715,7 +717,8 @@ uschar buffer[STRING_SPRINTF_BUFFER_SIZE];
 va_start(ap, format);
 if (!string_vformat(buffer, sizeof(buffer), format, ap))
   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
 va_start(ap, format);
 if (!string_vformat(buffer, sizeof(buffer), format, ap))
   log_write(0, LOG_MAIN|LOG_PANIC_DIE,

-    "string_sprintf expansion was longer than %d", sizeof(buffer));
+    "string_sprintf expansion was longer than " SIZE_T_FMT " (%s)",
+    sizeof(buffer), format);

 va_end(ap);
 return string_copy(buffer);
 }
 va_end(ap);
 return string_copy(buffer);
 }


@@ -964,6 +967,50 @@ return buffer;
 #endif  /* COMPILE_UTILITY */
 
 
 #endif  /* COMPILE_UTILITY */
 
 

+#ifndef COMPILE_UTILITY
+/************************************************
+*      Add element to seperated list           *
+************************************************/
+/* This function is used to build a list, returning
+an allocated null-terminated growable string. The
+given element has any embedded seperator characters
+doubled.
+
+Arguments:
+  list points to the start of the list that is being built, or NULL
+       if this is a new list that has no contents yet
+  sep  list seperator charactoer
+  ele  new lement to be appended to the list
+
+Returns:  pointer to the start of the list, changed if copied for expansion.
+*/
+
+uschar *
+string_append_listele(uschar * list, uschar sep, const uschar * ele)
+{
+uschar * new = NULL;
+int sz = 0, off = 0;
+uschar * sp;
+
+if (list)
+  {
+  new = string_cat(new, &sz, &off, list, Ustrlen(list));
+  new = string_cat(new, &sz, &off, &sep, 1);
+  }
+
+while((sp = Ustrchr(ele, sep)))
+  {
+  new = string_cat(new, &sz, &off, ele, sp-ele+1);
+  new = string_cat(new, &sz, &off, &sep, 1);
+  ele = sp+1;
+  }
+new = string_cat(new, &sz, &off, ele, Ustrlen(ele));
+new[off] = '\0';
+return new;
+}
+#endif  /* COMPILE_UTILITY */
+
+

 
 #ifndef COMPILE_UTILITY
 /*************************************************
 
 #ifndef COMPILE_UTILITY
 /*************************************************


@@ -1133,7 +1180,8 @@ return yield;
 BOOL
 string_vformat(uschar *buffer, int buflen, const char *format, va_list ap)
 {
 BOOL
 string_vformat(uschar *buffer, int buflen, const char *format, va_list ap)
 {

-enum { L_NORMAL, L_SHORT, L_LONG, L_LONGLONG, L_LONGDOUBLE };
+/* We assume numbered ascending order, C does not guarantee that */
+enum { L_NORMAL=1, L_SHORT=2, L_LONG=3, L_LONGLONG=4, L_LONGDOUBLE=5, L_SIZE=6 };

 
 BOOL yield = TRUE;
 int width, precision;
 
 BOOL yield = TRUE;
 int width, precision;


@@ -1203,7 +1251,7 @@ while (*fp != 0)
       }
     }
 
       }
     }
 

-  /* Skip over 'h', 'L', 'l', and 'll', remembering the item length */
+  /* Skip over 'h', 'L', 'l', 'll' and 'z', remembering the item length */

 
   if (*fp == 'h')
     { fp++; length = L_SHORT; }
 
   if (*fp == 'h')
     { fp++; length = L_SHORT; }


@@ -1222,6 +1270,8 @@ while (*fp != 0)
       length = L_LONG;
       }
     }
       length = L_LONG;
       }
     }

+  else if (*fp == 'z')
+    { fp++; length = L_SIZE; }

 
   /* Handle each specific format type. */
 
 
   /* Handle each specific format type. */
 


@@ -1251,6 +1301,7 @@ while (*fp != 0)
       case L_NORMAL:   sprintf(CS p, newformat, va_arg(ap, int)); break;
       case L_LONG:     sprintf(CS p, newformat, va_arg(ap, long int)); break;
       case L_LONGLONG: sprintf(CS p, newformat, va_arg(ap, LONGLONG_T)); break;
       case L_NORMAL:   sprintf(CS p, newformat, va_arg(ap, int)); break;
       case L_LONG:     sprintf(CS p, newformat, va_arg(ap, long int)); break;
       case L_LONGLONG: sprintf(CS p, newformat, va_arg(ap, LONGLONG_T)); break;

+      case L_SIZE:     sprintf(CS p, newformat, va_arg(ap, size_t)); break;

       }
     while (*p) p++;
     break;
       }
     while (*p) p++;
     break;