Line data    Source code

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