Back to index

webcit  8.12-dfsg
utils.c
Go to the documentation of this file.
00001 /*
00002  * de/encoding stuff. hopefully mostly to be depricated in favour of subst.c + strbuf
00003  */
00004 
00005 #define SHOW_ME_VAPPEND_PRINTF
00006 #include <stdio.h>
00007 #include <stdarg.h>
00008 #include "webcit.h"
00009 
00010 
00011 /*   
00012  * remove escaped strings from i.e. the url string (like %20 for blanks)
00013  */
00014 long unescape_input(char *buf)
00015 {
00016        unsigned int a, b;
00017        char hex[3];
00018        long buflen;
00019        long len;
00020 
00021        buflen = strlen(buf);
00022 
00023        while ((buflen > 0) && (isspace(buf[buflen - 1]))){
00024               buf[buflen - 1] = 0;
00025               buflen --;
00026        }
00027 
00028        a = 0; 
00029        while (a < buflen) {
00030               if (buf[a] == '+')
00031                      buf[a] = ' ';
00032               if (buf[a] == '%') {
00033                      /* don't let % chars through, rather truncate the input. */
00034                      if (a + 2 > buflen) {
00035                             buf[a] = '\0';
00036                             buflen = a;
00037                      }
00038                      else {               
00039                             hex[0] = buf[a + 1];
00040                             hex[1] = buf[a + 2];
00041                             hex[2] = 0;
00042                             b = 0;
00043                             b = decode_hex(hex);
00044                             buf[a] = (char) b;
00045                             len = buflen - a - 2;
00046                             if (len > 0)
00047                                    memmove(&buf[a + 1], &buf[a + 3], len);
00048                      
00049                             buflen -=2;
00050                      }
00051               }
00052               a++;
00053        }
00054        return a;
00055 }
00056 
00057 /*
00058  * Copy a string, escaping characters which have meaning in HTML.  
00059  *
00060  * target              target buffer
00061  * strbuf              source buffer
00062  * nbsp                        If nonzero, spaces are converted to non-breaking spaces.
00063  * nolinebreaks                if set, linebreaks are removed from the string.
00064  */
00065 long stresc(char *target, long tSize, char *strbuf, int nbsp, int nolinebreaks)
00066 {
00067         char *aptr, *bptr, *eptr;
00068  
00069         *target = '\0';
00070         aptr = strbuf;
00071         bptr = target;
00072         eptr = target + tSize - 6; /* our biggest unit to put in...  */
00073  
00074  
00075         while ((bptr < eptr) && !IsEmptyStr(aptr) ){
00076                 if (*aptr == '<') {
00077                         memcpy(bptr, "&lt;", 4);
00078                         bptr += 4;
00079                 }
00080                 else if (*aptr == '>') {
00081                         memcpy(bptr, "&gt;", 4);
00082                         bptr += 4;
00083                 }
00084                 else if (*aptr == '&') {
00085                         memcpy(bptr, "&amp;", 5);
00086                         bptr += 5;
00087                 }
00088                 else if (*aptr == '\"') {
00089                         memcpy(bptr, "&quot;", 6);
00090                         bptr += 6;
00091                 }
00092                 else if (*aptr == '\'') {
00093                         memcpy(bptr, "&#39;", 5);
00094                         bptr += 5;
00095                 }
00096                 else if (*aptr == LB) {
00097                         *bptr = '<';
00098                         bptr ++;
00099                 }
00100                 else if (*aptr == RB) {
00101                         *bptr = '>';
00102                         bptr ++;
00103                 }
00104                 else if (*aptr == QU) {
00105                         *bptr ='"';
00106                         bptr ++;
00107                 }
00108                 else if ((*aptr == 32) && (nbsp == 1)) {
00109                         memcpy(bptr, "&nbsp;", 6);
00110                         bptr += 6;
00111                 }
00112                 else if ((*aptr == '\n') && (nolinebreaks)) {
00113                         *bptr='\0';     /* nothing */
00114                 }
00115                 else if ((*aptr == '\r') && (nolinebreaks)) {
00116                         *bptr='\0';     /* nothing */
00117                 }
00118                 else{
00119                         *bptr = *aptr;
00120                         bptr++;
00121                 }
00122                 aptr ++;
00123         }
00124         *bptr = '\0';
00125         if ((bptr = eptr - 1 ) && !IsEmptyStr(aptr) )
00126                 return -1;
00127         return (bptr - target);
00128 }
00129 
00130 /* 
00131  * static wrapper for ecsputs1
00132  */
00133 void escputs(const char *strbuf)
00134 {
00135        StrEscAppend(WC->WBuf, NULL, strbuf, 0, 0);
00136 }
00137 
00138 /*
00139  * urlescape buffer and print it to the client
00140  */
00141 void urlescputs(const char *strbuf)
00142 {
00143        StrBufUrlescAppend(WC->WBuf, NULL, strbuf);
00144 }
00145 
00146 
00150 void hurlescputs(const char *strbuf) 
00151 {
00152        StrBufUrlescAppend(WC->HBuf, NULL, strbuf);
00153 }
00154 
00155 
00156 /*
00157  * Output a string to the client as a CDATA block
00158  */
00159 void cdataout(char *rawdata)
00160 {
00161        char *ptr = rawdata;
00162        wc_printf("<![CDATA[");
00163 
00164        while ((ptr != NULL) && (ptr[0] != 0))
00165        {
00166               if (!strncmp(ptr, "]]>", 3)) {
00167                      wc_printf("]]]]><![CDATA[>");
00168                      ++ptr; ++ptr; ++ptr;
00169               }
00170               else {
00171                      wc_printf("%c", ptr[0]);
00172                      ++ptr;
00173               }
00174        }
00175 
00176        wc_printf("]]>");
00177 }
00178