static JsonEl *NewString(const unsigned char *s, size_t len)
{
JsonElString *el = SA(JsonElString);
el->type = JsonTypeString;
el->stringVal = strdupn((const char*)s, len);
return (JsonEl*)el;
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
boolean mSQLDBConnection::connect(Properties *cfg){
char *tmp = strdupn( cfg->get(DBC_HOST) );
sock = msqlConnect(tmp);
free(tmp);
if (sock < 0)
return false;
tmp = strdupn( cfg->get(DBC_DATABASE) );
if (msqlSelectDB(sock, tmp) < 0){
//msqlClose(sock);
sock = -1;
static JsonElMapData *NewMapData(const unsigned char *key, size_t keyLen)
{
JsonElMapData *mapData = SA(JsonElMapData);
mapData->next = NULL;
mapData->val = NULL;
mapData->key = strdupn((const char*)key, keyLen);
return mapData;
}
void Properties::putParsedStr(const char *s, char delim){
if (isempty(s))
return;
StringTokenizer *st = new StringTokenizer(s, delim);
char *tmp1 = strdupn(st->nextToken());
char *tmp2 = strdupn(st->nextToEnd());
const char *name = strcut(tmp1);
const char *value = strcut(tmp2);
put(name, value);
free(tmp1);
free(tmp2);
delete(st);
};
int XMLParser::cmpTag(const char *tag1, const char *tag2){
char *tag_1=strdupn(tag1);
char *tag_2=strdupn(tag2);
char *t1 =cutTag(tag_1);
char *t2 =cutTag(tag_2);
char *t1_ =strconcat(OFFTAG, t1);
int x = 0;
if (!stricmpn(t1, t2))
x++;
else if (!strcmpn(t1_, t2))
x--;
free(tag_1);
free(tag_2);
free(t1_);
return x;
};
I getdelim_(S *s,I *n,I d,FILE *f)
{
I m; S z;size_t o=*n;
if(getdelim(s,&o,d,f)==-1){*n=0; R -1;}
*n=o;
m=strlenn(*s,*n);
if(1<m && '\n'==(*s)[m-1] && '\r'==(*s)[m-2]) {
(*s)[--m]='\0'; (*s)[m-1]='\n'; }
z=strdupn(*s,m);
free(*s);
*s=z;
R *n=m;
}
const char *MacroCodeReplacer::replaceField(const char *field){
if (isempty(field))
return NULL;
size_t l = strlen(field);
char *tmpfield = strdupn(field);
char MACROS = MACROS_NONE;
char MACROS1 = MACROS_NONE;
getOpt(1); //singles [xxx[a]
getOpt(2); //doubles [xxx[a]
const char *res = MacroReplacer::replaceField(tmpfield);
free(tmpfield);
const char *tmp;
switch(MACROS){
case MACROS_HTML : tmp = coder->HTMLEncode(res); break;
case MACROS_SOFT_HTML : tmp = coder->SoftHTMLEncode(res); break;
case MACROS_PHTML : tmp = coder->HTMLEncode(res, true); break;
case MACROS_SOFT_PHTML: tmp = coder->SoftHTMLEncode(res, true); break;
case MACROS_URL : tmp = coder->URLEncode(res); break;
case MACROS_NUMBER : tmp = coder->numberEncode(res); break;
case MACROS_FLOAT : tmp = coder->floatEncode(res, ctoi(MACROS1)); break;
case MACROS_SQL : tmp = coder->sqlEncode(res); break;
case MACROS_SQLNULL : tmp = coder->sqlNullEncode(res); break;
case MACROS_NO : tmp = res; break;
default : tmp = res;
printflog(LOG_NOTIFY, "Macrocode: Using macros without encoding.\n");
}
return tmp;
};
Z S sdup(S s){R strdupn(s,strlen(s));} //using this because "strdup" uses [used] dynamically linked malloc which fails with our static free
//S spkC(K a){S u=strdupn(kC(a),a->n),v=sp(u);free(u);R v;}
S spn(S s,I n){I k=0;while(k<n && s[k])k++; S u=strdupn(s,k); if(!u)R 0; S v=sp(u); free(u); R v;} //safer/memory-efficient strdupn
static Tok *number(int base)
{
Tok *t;
int start;
int c;
int isfloat;
int unsignedval;
/* because we allow '_' in numbers, and strtod/stroull don't, we
* need a buffer that holds the number without '_'.
*/
char buf[2048];
size_t nbuf;
t = NULL;
isfloat = 0;
start = fidx;
nbuf = 0;
for (c = peek(); isxdigit(c) || c == '.' || c == '_'; c = peek()) {
next();
if (c == '_')
continue;
if (c == '.')
isfloat = 1;
else if (hexval(c) < 0 || hexval(c) > base)
lfatal(curloc, "Integer digit '%c' outside of base %d", c, base);
if (nbuf >= sizeof buf - 1) {
buf[nbuf-1] = '\0';
lfatal(curloc, "number %s... too long to represent", buf);
}
buf[nbuf++] = c;
}
buf[nbuf] = '\0';
/* we only support base 10 floats */
if (isfloat && base == 10) {
t = mktok(Tfloatlit);
t->id = strdupn(&fbuf[start], fidx - start);
t->fltval = strtod(buf, NULL);
} else {
t = mktok(Tintlit);
t->id = strdupn(&fbuf[start], fidx - start);
t->intval = strtoull(buf, NULL, base);
/* check suffixes:
* u -> unsigned
* l -> 64 bit
* i -> 32 bit
* w -> 16 bit
* b -> 8 bit
*/
unsignedval = 0;
nextsuffix:
switch (peek()) {
case 'u':
if (unsignedval == 1)
lfatal(curloc, "Duplicate 'u' integer specifier");
next();
unsignedval = 1;
goto nextsuffix;
case 'l':
next();
if (unsignedval)
t->inttype = Tyuint64;
else
t->inttype = Tyint64;
break;
case 'i':
next();
if (unsignedval)
t->inttype = Tyuint32;
else
t->inttype = Tyint32;
break;
case 's':
next();
if (unsignedval)
t->inttype = Tyuint16;
else
t->inttype = Tyint16;
break;
case 'b':
next();
if (unsignedval)
t->inttype = Tyuint8;
else
t->inttype = Tyint8;
break;
default:
if (unsignedval)
lfatal(curloc, "Unrecognized character int type specifier after 'u'");
break;
}
}
return t;
}
static st32 mprint(RMagic *ms, struct r_magic *m) {
ut64 v;
float vf;
double vd;
ut64 t = 0;
char *buf = NULL;
union VALUETYPE *p = &ms->ms_value;
switch (m->type) {
case FILE_BYTE:
v = file_signextend(ms, m, (ut64)p->b);
switch (check_fmt(ms, m)) {
case -1:
return -1;
case 1:
buf = malloc (2);
if (snprintf (buf, 2, "%c", (ut8)v)<0) {
free (buf);
return -1;
}
if (file_printf (ms, R_MAGIC_DESC, buf) == -1) {
free (buf);
return -1;
}
break;
default:
if (file_printf(ms, R_MAGIC_DESC, (ut8) v) == -1)
return -1;
break;
}
t = ms->offset + sizeof(char);
break;
case FILE_SHORT:
case FILE_BESHORT:
case FILE_LESHORT:
v = file_signextend (ms, m, (ut64)p->h);
switch (check_fmt (ms, m)) {
case -1:
return -1;
case 1:
buf = malloc (32);
if (snprintf (buf, 32, "%hu", (unsigned short)v) < 0) {
free (buf);
return -1;
}
if (file_printf(ms, R_MAGIC_DESC, buf) == -1) {
free (buf);
return -1;
}
break;
default:
if (file_printf(ms, R_MAGIC_DESC, (unsigned short) v) == -1)
return -1;
break;
}
t = ms->offset + sizeof(short);
break;
case FILE_LONG:
case FILE_BELONG:
case FILE_LELONG:
case FILE_MELONG:
v = file_signextend(ms, m, (ut64)p->l);
switch (check_fmt(ms, m)) {
case -1:
return -1;
case 1:
buf = malloc (32);
if (snprintf (buf, 32, "%u", (ut32)v) < 0) {
free (buf);
return -1;
}
if (file_printf(ms, R_MAGIC_DESC, buf) == -1) {
free (buf);
return -1;
}
break;
default:
if (file_printf(ms, R_MAGIC_DESC, (ut32) v) == -1)
return -1;
break;
}
t = ms->offset + sizeof(st32);
break;
case FILE_QUAD:
case FILE_BEQUAD:
case FILE_LEQUAD:
v = file_signextend(ms, m, p->q);
if (file_printf(ms, R_MAGIC_DESC, (ut64) v) == -1)
return -1;
t = ms->offset + sizeof(ut64);
break;
case FILE_STRING:
case FILE_PSTRING:
case FILE_BESTRING16:
case FILE_LESTRING16:
if (m->reln == '=' || m->reln == '!') {
if (file_printf (ms, R_MAGIC_DESC, m->value.s) == -1)
return -1;
t = ms->offset + m->vallen;
}
else {
if (*m->value.s == '\0')
p->s[strcspn (p->s, "\n")] = '\0';
if (file_printf (ms, R_MAGIC_DESC, p->s) == -1)
return -1;
t = ms->offset + strlen (p->s);
if (m->type == FILE_PSTRING)
t++;
}
break;
case FILE_DATE:
case FILE_BEDATE:
case FILE_LEDATE:
case FILE_MEDATE:
if (file_printf(ms, R_MAGIC_DESC, file_fmttime(p->l, 1)) == -1)
return -1;
t = ms->offset + sizeof(time_t);
break;
case FILE_LDATE:
case FILE_BELDATE:
case FILE_LELDATE:
case FILE_MELDATE:
if (file_printf(ms, R_MAGIC_DESC, file_fmttime(p->l, 0)) == -1)
return -1;
t = ms->offset + sizeof(time_t);
break;
case FILE_QDATE:
case FILE_BEQDATE:
case FILE_LEQDATE:
if (file_printf(ms, R_MAGIC_DESC, file_fmttime((ut32)p->q, 1))
== -1)
return -1;
t = ms->offset + sizeof(ut64);
break;
case FILE_QLDATE:
case FILE_BEQLDATE:
case FILE_LEQLDATE:
if (file_printf(ms, R_MAGIC_DESC, file_fmttime((ut32)p->q, 0))
== -1)
return -1;
t = ms->offset + sizeof(ut64);
break;
case FILE_FLOAT:
case FILE_BEFLOAT:
case FILE_LEFLOAT:
vf = p->f;
switch (check_fmt(ms, m)) {
case -1:
return -1;
case 1:
buf = malloc (32);
if (snprintf (buf, 32, "%g", vf) < 0) {
free (buf);
return -1;
}
if (file_printf (ms, R_MAGIC_DESC, buf) == -1) {
free (buf);
return -1;
}
break;
default:
if (file_printf(ms, R_MAGIC_DESC, vf) == -1)
return -1;
break;
}
t = ms->offset + sizeof(float);
break;
case FILE_DOUBLE:
case FILE_BEDOUBLE:
case FILE_LEDOUBLE:
vd = p->d;
switch (check_fmt(ms, m)) {
case -1:
return -1;
case 1:
buf = malloc (32);
if (snprintf (buf, 32, "%g", vd) < 0) {
free (buf);
return -1;
}
if (file_printf (ms, R_MAGIC_DESC, buf) == -1) {
free (buf);
return -1;
}
break;
default:
if (file_printf(ms, R_MAGIC_DESC, vd) == -1)
return -1;
break;
}
t = ms->offset + sizeof(double);
break;
case FILE_REGEX: {
char *cp;
int rval;
cp = strdupn((const char *)ms->search.s, ms->search.rm_len);
if (cp == NULL) {
file_oomem(ms, ms->search.rm_len);
return -1;
}
rval = file_printf(ms, R_MAGIC_DESC, cp);
free(cp);
if (rval == -1)
return -1;
if ((m->str_flags & REGEX_OFFSET_START))
t = ms->search.offset;
else
t = ms->search.offset + ms->search.rm_len;
break;
}
case FILE_SEARCH:
if (file_printf(ms, R_MAGIC_DESC, m->value.s) == -1)
return -1;
if ((m->str_flags & REGEX_OFFSET_START))
t = ms->search.offset;
else t = ms->search.offset + m->vallen;
break;
case FILE_DEFAULT:
if (file_printf(ms, R_MAGIC_DESC, m->value.s) == -1)
return -1;
t = ms->offset;
break;
default:
file_magerror(ms, "invalid m->type (%d) in mprint()", m->type);
return -1;
}
free (buf);
return(t);
}
static Tok *number(int base)
{
Tok *t;
int start;
int c;
int isfloat;
int unsignedval;
t = NULL;
isfloat = 0;
start = fidx;
for (c = peek(); isxdigit(c) || c == '.' || c == '_'; c = peek()) {
next();
if (c == '_')
continue;
if (c == '.')
isfloat = 1;
else if (hexval(c) < 0 || hexval(c) > base)
fatal(line, "Integer digit '%c' outside of base %d", c, base);
}
/* we only support base 10 floats */
if (isfloat && base == 10) {
t = mktok(Tfloatlit);
t->str = strdupn(&fbuf[start], fidx - start);
t->fltval = strtod(t->str, NULL);
} else {
t = mktok(Tintlit);
t->str = strdupn(&fbuf[start], fidx - start);
t->intval = strtol(t->str, NULL, base);
/* check suffixes:
* u -> unsigned
* l -> 64 bit
* i -> 32 bit
* w -> 16 bit
* b -> 8 bit
*/
unsignedval = 0;
nextsuffix:
switch (peek()) {
case 'u':
if (unsignedval == 1)
fatal(line, "Duplicate 'u' integer specifier");
next();
unsignedval = 1;
goto nextsuffix;
case 'l':
next();
if (unsignedval)
t->inttype = Tyuint64;
else
t->inttype = Tyint64;
break;
case 'i':
next();
if (unsignedval)
t->inttype = Tyuint32;
else
t->inttype = Tyint32;
break;
case 's':
next();
if (unsignedval)
t->inttype = Tyuint16;
else
t->inttype = Tyint16;
break;
case 'b':
next();
if (unsignedval)
t->inttype = Tyuint8;
else
t->inttype = Tyint8;
break;
default:
if (unsignedval)
fatal(line, "Unrecognized character int type specifier after 'u'");
break;
}
}
return t;
}
PropertiesNode::PropertiesNode(const char *key, const char *value){
this->key = strdupn(key);
this->value = strdupn(value);
};
