Line data    Source code

       1             : #include "burp.h"
       2             : #include "alloc.h"
       3             : #include "log.h"
       4             : 
       5             : /* This may be given binary data, of which we need to already know the length */
       6       37792 : char *prepend_len(const char *prep, size_t plen, const char *fname,
       7             :         size_t flen, const char *sep, size_t slen, size_t *newlen)
       8             : {
       9       37792 :         size_t l=0;
      10       37792 :         char *rpath=NULL;
      11             : 
      12       37792 :         l+=plen;
      13       37792 :         l+=flen;
      14       37792 :         l+=slen;
      15       37792 :         l+=1;
      16             : 
      17       37792 :         if(!(rpath=(char *)malloc_w(l, __func__)))
      18             :                 return NULL;
      19       37792 :         if(plen) memcpy(rpath,           prep,  plen);
      20       37792 :         if(slen) memcpy(rpath+plen,      sep,   slen);
      21       37792 :         if(flen) memcpy(rpath+plen+slen, fname, flen);
      22       37792 :         rpath[plen+slen+flen]='\0';
      23             : 
      24       37792 :         if(newlen) (*newlen)+=slen+flen;
      25       37792 :         return rpath;
      26             : }
      27             : 
      28       37784 : char *prepend_n(const char *prep, const char *fname,
      29             :         size_t len, const char *sep)
      30             : {
      31             :         return prepend_len(prep, prep?strlen(prep):0,
      32             :                 fname, len,
      33       37784 :                 sep, (sep && *fname)?strlen(sep):0, NULL);
      34             : }
      35             : 
      36        1507 : char *prepend(const char *prep, const char *fname)
      37             : {
      38        1507 :         return prepend_n(prep, fname, strlen(fname), "");
      39             : }
      40             : 
      41       36198 : char *prepend_slash(const char *prep, const char *fname, size_t len)
      42             : {
      43       36198 :         if(!prep || !*prep)
      44          39 :                 return strdup_w(fname, __func__);
      45             :         // Try to avoid getting a double slash in the path.
      46       36159 :         if(fname && fname[0]=='/')
      47             :         {
      48        7405 :                 fname++;
      49        7405 :                 len--;
      50             :         }
      51       36159 :         return prepend_n(prep, fname, len, "/");
      52             : }
      53             : 
      54       36174 : char *prepend_s(const char *prep, const char *fname)
      55             : {
      56       36174 :         return prepend_slash(prep, fname, strlen(fname));
      57             : }
      58             : 
      59      329178 : int astrcat(char **buf, const char *append, const char *func)
      60             : {
      61      329178 :         int l=0;
      62      329178 :         char *copy=NULL;
      63      329178 :         if(append) l+=strlen(append);
      64      329178 :         if(*buf) l+=strlen(*buf);
      65      329178 :         l++;
      66      611164 :         if((*buf && !(copy=strdup_w(*buf, __func__)))
      67      658356 :           || !(*buf=(char *)realloc_w(*buf, l, __func__)))
      68             :         {
      69           0 :                 log_oom_w(__func__, func);
      70           0 :                 return -1;
      71             :         }
      72      329178 :         snprintf(*buf, l, "%s%s", copy?copy:"", append?append:"");
      73      329178 :         free_w(&copy);
      74      329178 :         return 0;
      75             : }