*/ void Adjust_Date_Zone(REBVAL *d, REBFLG to_utc) /* ** Adjust date and time for the timezone. ** The result should be used for output, not stored. ** ***********************************************************************/ { REBI64 secs; REBCNT n; if (VAL_ZONE(d) == 0) return; if (VAL_TIME(d) == NO_TIME) { VAL_TIME(d) = VAL_ZONE(d) = 0; return; } // (compiler should fold the constant) secs = ((i64)VAL_ZONE(d) * ((i64)ZONE_SECS * SEC_SEC)); if (to_utc) secs = -secs; secs += VAL_TIME(d); VAL_TIME(d) = (secs + TIME_IN_DAY) % TIME_IN_DAY; n = VAL_DAY(d) - 1; if (secs < 0) n--; else if (secs >= TIME_IN_DAY) n++; else return; VAL_DATE(d) = Normalize_Date(n, VAL_MONTH(d)-1, VAL_YEAR(d), VAL_ZONE(d)); }
// // Scan_Time: C // // Scan string and convert to time. Return zero if error. // const REBYTE *Scan_Time(const REBYTE *cp, REBCNT len, REBVAL *value) { const REBYTE *sp; REBYTE merid = FALSE; REBOOL neg = FALSE; REBINT part1, part2, part3 = -1; REBINT part4 = -1; if (*cp == '-') cp++, neg = TRUE; else if (*cp == '+') cp++; if (*cp == '-' || *cp == '+') return 0; // small hole: --1:23 // Can be: // HH:MM as part1:part2 // HH:MM:SS as part1:part2:part3 // HH:MM:SS.DD as part1:part2:part3.part4 // MM:SS.DD as part1:part2.part4 cp = Grab_Int(cp, &part1); if (part1 > MAX_HOUR) return 0; if (*cp++ != ':') return 0; sp = Grab_Int(cp, &part2); if (part2 < 0 || sp == cp) return 0; cp = sp; if (*cp == ':') { // optional seconds sp = cp + 1; cp = Grab_Int(sp, &part3); if (part3 < 0 || cp == sp) return 0; //part3 = -1; } if (*cp == '.' || *cp == ',') { sp = ++cp; cp = Grab_Int_Scale(sp, &part4, 9); if (part4 == 0) part4 = -1; } if ((UP_CASE(*cp) == 'A' || UP_CASE(*cp) == 'P') && (UP_CASE(cp[1]) == 'M')) { merid = (REBYTE)UP_CASE(*cp); cp += 2; } if (part3 >= 0 || part4 < 0) { // HH:MM mode if (merid) { if (part1 > 12) return 0; if (part1 == 12) part1 = 0; if (merid == 'P') part1 += 12; } if (part3 < 0) part3 = 0; VAL_TIME(value) = HOUR_TIME(part1) + MIN_TIME(part2) + SEC_TIME(part3); } else { // MM:SS mode if (merid) return 0; // no AM/PM for minutes VAL_TIME(value) = MIN_TIME(part1) + SEC_TIME(part2); } if (part4 > 0) VAL_TIME(value) += part4; if (neg) VAL_TIME(value) = -VAL_TIME(value); VAL_SET(value, REB_TIME); return cp; }
// // Cmp_Time: C // // Given two times, compare them. // REBINT Cmp_Time(const REBVAL *v1, const REBVAL *v2) { REBI64 t1 = VAL_TIME(v1); REBI64 t2 = VAL_TIME(v2); if (t1 == NO_TIME) t1 = 0L; if (t2 == NO_TIME) t2 = 0L; if (t2 == t1) return 0; if (t1 > t2) return 1; return -1; }
*/ REBINT CT_Date(REBVAL *a, REBVAL *b, REBINT mode) /* ***********************************************************************/ { REBINT num = Cmp_Date(a, b); if (mode >= 2) return VAL_DATE(a).bits == VAL_DATE(b).bits && VAL_TIME(a) == VAL_TIME(b); if (mode >= 0) return (num == 0); if (mode == -1) return (num >= 0); return (num > 0); }
int bdb_ufield_db2bdb(bdb_uval_p v, db_val_t* _v) { char *s; VAL_NULL(&(v->v)) = VAL_NULL(_v); VAL_TYPE(&(v->v)) = VAL_TYPE(_v); if (!VAL_NULL(&(v->v))) { switch (VAL_TYPE(_v)) { case DB_INT: VAL_INT(&(v->v)) = VAL_INT(_v); break; case DB_FLOAT: VAL_FLOAT(&(v->v)) = VAL_FLOAT(_v); break; case DB_DATETIME: VAL_TIME(&(v->v)) = VAL_TIME(_v); break; case DB_BLOB: s = pkg_malloc(VAL_BLOB(_v).len); memcpy(s, VAL_BLOB(_v).s, VAL_BLOB(_v).len); VAL_BLOB(&(v->v)).s = s; VAL_BLOB(&(v->v)).len = VAL_BLOB(_v).len; break; case DB_DOUBLE: VAL_DOUBLE(&(v->v)) = VAL_DOUBLE(_v); break; case DB_STRING: VAL_STR(&(v->v)).len = strlen(VAL_STRING(_v)) + 1; s = pkg_malloc(VAL_STR(&(v->v)).len); strcpy(s, VAL_STRING(_v)); VAL_STRING(&(v->v)) = s; break; case DB_STR: s = pkg_malloc(VAL_STR(_v).len); memcpy(s, VAL_STR(_v).s, VAL_STR(_v).len); VAL_STR(&(v->v)).s = s; VAL_STR(&(v->v)).len = VAL_STR(_v).len; break; case DB_BITMAP: VAL_BITMAP(&(v->v)) = VAL_BITMAP(_v); break; default: LOG(L_ERR, "BDB:bdb_ufield_db2bdb: unknown column type: %0X\n", VAL_TYPE(_v)); return -1; break; } } return 0; };
int bdb_set_key(bdb_row_p _r, bdb_val_p _v) { /* NULL is not allowed for primary key */ if (VAL_NULL(&(_v->v))) { LOG(L_ERR, "BDB:bdb_set_key: NULL is not allowed for primary key\n"); return -1; } switch (VAL_TYPE(&(_v->v))) { case DB_INT: _r->key.data = &VAL_INT(&(_v->v)); _r->key.size = sizeof(VAL_INT(&(_v->v))); break; case DB_FLOAT: _r->key.data = &VAL_FLOAT(&(_v->v)); _r->key.size = sizeof(VAL_FLOAT(&(_v->v))); break; case DB_DATETIME: _r->key.data = &VAL_TIME(&(_v->v)); _r->key.size = sizeof(VAL_TIME(&(_v->v))); break; case DB_BLOB: _r->key.data = VAL_BLOB(&(_v->v)).s; _r->key.size = VAL_BLOB(&(_v->v)).len; break; case DB_DOUBLE: _r->key.data = &VAL_DOUBLE(&(_v->v)); _r->key.size = sizeof(VAL_DOUBLE(&(_v->v))); break; case DB_STRING: _r->key.data = (void *)VAL_STRING(&(_v->v)); _r->key.size = strlen(VAL_STRING(&(_v->v))) + 1; break; case DB_STR: _r->key.data = VAL_STR(&(_v->v)).s; _r->key.size = VAL_STR(&(_v->v)).len; break; case DB_BITMAP: _r->key.data = &VAL_BITMAP(&(_v->v)); _r->key.size = sizeof(VAL_BITMAP(&(_v->v))); break; default: LOG(L_ERR, "BDB:bdb_set_skey: unknown column type: %0X\n", VAL_TYPE(&(_v->v))); return -1; break; } return 0; };
*/ REBINT Cmp_Time(const REBVAL *v1, const REBVAL *v2) /* ** Given two times, compare them. ** ***********************************************************************/ { REBI64 t1 = VAL_TIME(v1); REBI64 t2 = VAL_TIME(v2); if (t1 == NO_TIME) t1 = 0L; if (t2 == NO_TIME) t2 = 0L; if (t2 == t1) return 0; if (t1 > t2) return 1; return -1; }
void bdb_set_skey(bdb_srow_p _r, bdb_sval_p _v) { /* NULL is not allowed for primary key */ if (VAL_NULL(&(_v->v))) return; switch (VAL_TYPE(&(_v->v))) { case DB_INT: _r->key.data = &VAL_INT(&(_v->v)); _r->key.size = sizeof(VAL_INT(&(_v->v))); break; case DB_FLOAT: _r->key.data = &VAL_FLOAT(&(_v->v)); _r->key.size = sizeof(VAL_FLOAT(&(_v->v))); break; case DB_DATETIME: _r->key.data = &VAL_TIME(&(_v->v)); _r->key.size = sizeof(VAL_TIME(&(_v->v))); break; case DB_BLOB: _r->key.data = VAL_BLOB(&(_v->v)).s; _r->key.size = VAL_BLOB(&(_v->v)).len; break; case DB_DOUBLE: _r->key.data = &VAL_DOUBLE(&(_v->v)); _r->key.size = sizeof(VAL_DOUBLE(&(_v->v))); break; case DB_STRING: _r->key.data = (void *)VAL_STRING(&(_v->v)); _r->key.size = strlen(VAL_STRING(&(_v->v))) + 1; break; case DB_STR: _r->key.data = VAL_STR(&(_v->v)).s; _r->key.size = VAL_STR(&(_v->v)).len; break; case DB_BITMAP: _r->key.data = &VAL_BITMAP(&(_v->v)); _r->key.size = sizeof(VAL_BITMAP(&(_v->v))); break; default: LOG(L_ERR, "BDB:bdb_set_skey: unknown column type: %0X\n", VAL_TYPE(&(_v->v))); break; } #ifdef BDB_EXTRA_DEBUG LOG(L_NOTICE, "BDB:bdb_set_skey: use key '%.*s' (%d bytes)\n", _r->key.size, (char *)_r->key.data, _r->key.size); #endif };
*/ void Emit_Time(REB_MOLD *mold, const REBVAL *value) /* ***********************************************************************/ { REB_TIMEF tf; const char *fmt; Split_Time(VAL_TIME(value), &tf); // loses sign if (tf.s == 0 && tf.n == 0) fmt = "I:2"; else fmt = "I:2:2"; if (VAL_TIME(value) < (REBI64)0) Append_Byte(mold->series, '-'); Emit(mold, fmt, tf.h, tf.m, tf.s, 0); if (tf.n > 0) Emit(mold, ".i", tf.n); }
// // Emit_Time: C // void Emit_Time(REB_MOLD *mold, const REBVAL *value) { REB_TIMEF tf; const char *fmt; Split_Time(VAL_TIME(value), &tf); // loses sign if (tf.s == 0 && tf.n == 0) fmt = "I:2"; else fmt = "I:2:2"; if (VAL_TIME(value) < cast(REBI64, 0)) Append_Codepoint_Raw(mold->series, '-'); Emit(mold, fmt, tf.h, tf.m, tf.s, 0); if (tf.n > 0) Emit(mold, ".i", tf.n); }
static int db_sqlite_bind_values(sqlite3_stmt* stmt, const db_val_t* v, const int n) { int i, ret; if (n>0 && v) { for (i=0; i<n; i++) { if (VAL_NULL(v+i)) { ret=sqlite3_bind_null(stmt, i+1); goto check_ret; } switch(VAL_TYPE(v+i)) { /* every param has '+1' index because in sqlite the leftmost * parameter has index '1' */ case DB_INT: ret=sqlite3_bind_int(stmt, i+1, VAL_INT(v+i)); break; case DB_BIGINT: ret=sqlite3_bind_int64(stmt, i+1, VAL_BIGINT(v+i)); break; case DB_DOUBLE: ret=sqlite3_bind_double(stmt, i+1, VAL_DOUBLE(v+i)); break; case DB_STRING: ret=sqlite3_bind_text(stmt, i+1, VAL_STRING(v+i), strlen(VAL_STRING(v+i)), SQLITE_STATIC); break; case DB_STR: ret=sqlite3_bind_text(stmt, i+1, VAL_STR(v+i).s, VAL_STR(v+i).len, SQLITE_STATIC); break; case DB_DATETIME: ret=sqlite3_bind_int64(stmt, i+1, (long int)VAL_TIME(v+i)); break; case DB_BLOB: ret=sqlite3_bind_blob(stmt, i+1, (void*)VAL_BLOB(v+i).s, VAL_BLOB(v+i).len, SQLITE_STATIC); break; case DB_BITMAP: ret=sqlite3_bind_int(stmt, i+1, (int)VAL_BITMAP(v+i)); break; default: LM_BUG("invalid db type\n"); return 1; } check_ret: if (ret != SQLITE_OK) { return ret; } } } return SQLITE_OK; }
// // MT_Time: C // REBFLG MT_Time(REBVAL *out, REBVAL *data, enum Reb_Kind type) { REBI64 secs = Make_Time(data); if (secs == NO_TIME) return FALSE; VAL_SET(out, REB_TIME); VAL_TIME(out) = secs; VAL_DATE(out).bits = 0; return TRUE; }
inline SV *valdata(db_val_t* val) { SV *data = &PL_sv_undef; const char* stringval; switch(VAL_TYPE(val)) { case DB1_INT: data = newSViv(VAL_INT(val)); break; case DB1_BIGINT: LM_ERR("BIGINT not supported"); data = &PL_sv_undef; break; case DB1_DOUBLE: data = newSVnv(VAL_DOUBLE(val)); break; case DB1_STRING: stringval = VAL_STRING(val); if (strlen(stringval) > 0) data = newSVpv(stringval, strlen(stringval)); else data = &PL_sv_undef; break; case DB1_STR: if (VAL_STR(val).len > 0) data = newSVpv(VAL_STR(val).s, VAL_STR(val).len); else data = &PL_sv_undef; break; case DB1_DATETIME: data = newSViv((unsigned int)VAL_TIME(val)); break; case DB1_BLOB: if (VAL_BLOB(val).len > 0) data = newSVpv(VAL_BLOB(val).s, VAL_BLOB(val).len); else data = &PL_sv_undef; break; case DB1_BITMAP: data = newSViv(VAL_BITMAP(val)); break; } return data; }
*/ void Subtract_Date(REBVAL *d1, REBVAL *d2, REBVAL *result) /* ** Called by DIFFERENCE function. ** ***********************************************************************/ { REBINT diff; REBI64 t1; REBI64 t2; diff = Diff_Date(VAL_DATE(d1), VAL_DATE(d2)); if (cast(REBCNT, abs(diff)) > (((1U << 31) - 1) / SECS_IN_DAY)) Trap(RE_OVERFLOW); t1 = VAL_TIME(d1); if (t1 == NO_TIME) t1 = 0L; t2 = VAL_TIME(d2); if (t2 == NO_TIME) t2 = 0L; VAL_SET(result, REB_TIME); VAL_TIME(result) = (t1 - t2) + ((REBI64)diff * TIME_IN_DAY); }
*/ REBFLG MT_Time(REBVAL *out, REBVAL *data, REBCNT type) /* ***********************************************************************/ { REBI64 secs = Make_Time(data); if (secs == NO_TIME) return FALSE; VAL_SET(out, REB_TIME); VAL_TIME(out) = secs; VAL_DATE(out).bits = 0; return TRUE; }
int acc_db_request( struct sip_msg *rq, struct sip_msg *rpl, query_list_t **ins_list) { static db_ps_t my_ps_ins = NULL; static db_ps_t my_ps = NULL; int m; int n; int i; /* formated database columns */ m = core2strar( rq, val_arr ); for(i = 0; i < m; i++) VAL_STR(db_vals+i) = val_arr[i]; /* time value */ VAL_TIME(db_vals+(m++)) = acc_env.ts; /* extra columns */ m += extra2strar( db_extra, rq, rpl, val_arr+m, 0); for( i++; i < m; i++) VAL_STR(db_vals+i) = val_arr[i]; acc_dbf.use_table(db_handle, &acc_env.text/*table*/); CON_PS_REFERENCE(db_handle) = ins_list? &my_ps_ins : &my_ps; /* multi-leg columns */ if ( !leg_info ) { if (con_set_inslist(&acc_dbf,db_handle,ins_list,db_keys,m) < 0 ) CON_RESET_INSLIST(db_handle); if (acc_dbf.insert(db_handle, db_keys, db_vals, m) < 0) { LM_ERR("failed to insert into database\n"); return -1; } } else { n = legs2strar(leg_info,rq,val_arr+m,1); do { for ( i = m; i < m + n; i++) VAL_STR(db_vals+i)=val_arr[i]; if (con_set_inslist(&acc_dbf,db_handle,ins_list,db_keys,m+n) < 0 ) CON_RESET_INSLIST(db_handle); if (acc_dbf.insert(db_handle, db_keys, db_vals, m+n) < 0) { LM_ERR("failed to insert into database\n"); return -1; } }while ( (n = legs2strar(leg_info,rq,val_arr+m,0))!=0 ); } return 1; }
*/ void Set_Date(REBVAL *val, REBOL_DAT *dat) /* ** Convert OS date struct to REBOL value struct. ** NOTE: Input zone is in minutes. ** ***********************************************************************/ { VAL_YEAR(val) = dat->year; VAL_MONTH(val) = dat->month; VAL_DAY(val) = dat->day; VAL_ZONE(val) = dat->zone / ZONE_MINS; VAL_TIME(val) = TIME_SEC(dat->time) + dat->nano; VAL_SET(val, REB_DATE); }
*/ void Set_Date_UTC(REBVAL *val, REBINT y, REBINT m, REBINT d, REBI64 t, REBINT z) /* ** Convert date/time/zone to UTC with zone. ** ***********************************************************************/ { // Adjust for zone.... VAL_YEAR(val) = y; VAL_MONTH(val) = m; VAL_DAY(val) = d; VAL_TIME(val) = t; VAL_ZONE(val) = z; VAL_SET(val, REB_DATE); if (z) Adjust_Date_Zone(val, TRUE); }
int acc_db_request( struct sip_msg *rq) { int m; int n; int i; /* formated database columns */ m = core2strar( rq, val_arr, int_arr, type_arr ); for(i=0; i<m; i++) VAL_STR(db_vals+i) = val_arr[i]; /* time value */ VAL_TIME(db_vals+(m++)) = acc_env.ts; /* extra columns */ m += extra2strar( db_extra, rq, val_arr+m, int_arr+m, type_arr+m); for( i++ ; i<m; i++) VAL_STR(db_vals+i) = val_arr[i]; if (acc_dbf.use_table(db_handle, &acc_env.text/*table*/) < 0) { LM_ERR("error in use_table\n"); return -1; } /* multi-leg columns */ if ( !leg_info ) { if (acc_dbf.insert(db_handle, db_keys, db_vals, m) < 0) { LM_ERR("failed to insert into database\n"); return -1; } } else { n = legs2strar(leg_info,rq,val_arr+m,int_arr+m,type_arr+m,1); do { for (i=m; i<m+n; i++) VAL_STR(db_vals+i)=val_arr[i]; if (acc_dbf.insert(db_handle, db_keys, db_vals, m+n) < 0) { LM_ERR("failed to insert into database\n"); return -1; } }while ( (n=legs2strar(leg_info,rq,val_arr+m,int_arr+m, type_arr+m,0))!=0 ); } return 1; }
x*/ void RXI_To_Value(REBVAL *val, RXIARG arg, REBCNT type) /* ***********************************************************************/ { VAL_SET(val, RXT_To_Reb[type]); switch (RXT_Eval_Class[type]) { case RXX_64: VAL_INT64(val) = arg.int64; break; case RXX_SER: VAL_SERIES(val) = cast(REBSER*, arg.sri.series); VAL_INDEX(val) = arg.sri.index; break; case RXX_PTR: VAL_HANDLE_DATA(val) = arg.addr; break; case RXX_32: VAL_I32(val) = arg.i2.int32a; break; case RXX_DATE: VAL_TIME(val) = NO_TIME; VAL_ALL_BITS(val)[2] = arg.i2.int32a; break; case RXX_SYM: VAL_WORD_SYM(val) = arg.i2.int32a; VAL_WORD_FRAME(val) = 0; VAL_WORD_INDEX(val) = 0; break; case RXX_IMAGE: VAL_SERIES(val) = cast(REBSER*, arg.iwh.image); VAL_IMAGE_WIDE(val) = arg.iwh.width; VAL_IMAGE_HIGH(val) = arg.iwh.height; break; case RXX_NULL: VAL_INT64(val) = 0; break; default: SET_NONE(val); } }
/* * Convert a str to a db value, does not copy strings * The postgresql module uses a custom escape function for BLOBs. * If the _s is linked in the db_val result, it will be returned zero */ int db_postgres_str2val(const db_type_t _t, db_val_t* _v, const char* _s, const int _l) { static str dummy_string = {"", 0}; char *x; if (!_v) { LM_ERR("invalid parameter value\n"); return -1; } if (!_s) { memset(_v, 0, sizeof(db_val_t)); /* Initialize the string pointers to a dummy empty * string so that we do not crash when the NULL flag * is set but the module does not check it properly */ VAL_STR(_v) = dummy_string; VAL_TYPE(_v) = _t; VAL_NULL(_v) = 1; return 0; } VAL_NULL(_v) = 0; switch(_t) { case DB_INT: LM_DBG("converting INT [%s]\n", _s); if (db_str2int(_s, &VAL_INT(_v)) < 0) { LM_ERR("failed to convert INT value from string\n"); return -2; } else { VAL_TYPE(_v) = DB_INT; return 0; } break; case DB_BIGINT: LM_DBG("converting BIGINT [%s]\n", _s); if (db_str2bigint(_s, &VAL_BIGINT(_v)) < 0) { LM_ERR("failed to convert BIGINT value from string\n"); return -2; } else { VAL_TYPE(_v) = DB_BIGINT; return 0; } break; case DB_BITMAP: LM_DBG("converting BITMAP [%s]\n", _s); if (db_str2int(_s, &VAL_INT(_v)) < 0) { LM_ERR("failed to convert BITMAP value from string\n"); return -3; } else { VAL_TYPE(_v) = DB_BITMAP; return 0; } break; case DB_DOUBLE: LM_DBG("converting DOUBLE [%s]\n", _s); if (db_str2double(_s, &VAL_DOUBLE(_v)) < 0) { LM_ERR("failed to convert DOUBLE value from string\n"); return -4; } else { VAL_TYPE(_v) = DB_DOUBLE; return 0; } break; case DB_STRING: LM_DBG("converting STRING [%s]\n", _s); VAL_STRING(_v) = _s; VAL_TYPE(_v) = DB_STRING; VAL_FREE(_v) = 1; return 0; case DB_STR: LM_DBG("converting STR [%.*s]\n", _l, _s); VAL_STR(_v).s = (char*)_s; VAL_STR(_v).len = _l; VAL_TYPE(_v) = DB_STR; VAL_FREE(_v) = 1; return 0; case DB_DATETIME: LM_DBG("converting DATETIME [%s]\n", _s); if (db_str2time(_s, &VAL_TIME(_v)) < 0) { LM_ERR("failed to convert datetime\n"); return -5; } else { VAL_TYPE(_v) = DB_DATETIME; return 0; } break; case DB_BLOB: LM_DBG("converting BLOB [%.*s]\n", _l, _s); /* PQunescapeBytea: Converts a string representation of binary data * into binary data - the reverse of PQescapeBytea. * This is needed when retrieving bytea data in text format, * but not when retrieving it in binary format. */ x = (char*)PQunescapeBytea((unsigned char*)_s, (size_t*)(void*)&(VAL_BLOB(_v).len) ); VAL_BLOB(_v).s = pkg_malloc( VAL_BLOB(_v).len+1 ); if (VAL_BLOB(_v).s==NULL) { LM_ERR("failed to allocate pkg for BLOB\n"); return -6; } memcpy( VAL_BLOB(_v).s, x, VAL_BLOB(_v).len); VAL_BLOB(_v).s[VAL_BLOB(_v).len]='\0'; free(x); VAL_TYPE(_v) = DB_BLOB; VAL_FREE(_v) = 1; LM_DBG("got blob len %d\n", _l); return 0; } return -6; }
*/ REBINT PD_Time(REBPVS *pvs) /* ***********************************************************************/ { REBVAL *val; REBINT i; REBINT n; REBDEC f; REB_TIMEF tf; if (IS_WORD(pvs->select)) { switch (VAL_WORD_CANON(pvs->select)) { case SYM_HOUR: i = 0; break; case SYM_MINUTE: i = 1; break; case SYM_SECOND: i = 2; break; default: return PE_BAD_SELECT; } } else if (IS_INTEGER(pvs->select)) i = VAL_INT32(pvs->select) - 1; else return PE_BAD_SELECT; Split_Time(VAL_TIME(pvs->value), &tf); // loses sign if (!(val = pvs->setval)) { val = pvs->store; switch(i) { case 0: // hours SET_INTEGER(val, tf.h); break; case 1: SET_INTEGER(val, tf.m); break; case 2: if (tf.n == 0) SET_INTEGER(val, tf.s); else SET_DECIMAL(val, (REBDEC)tf.s + (tf.n * NANO)); break; default: return PE_NONE; } return PE_USE; } else { if (IS_INTEGER(val) || IS_DECIMAL(val)) n = Int32s(val, 0); else if (IS_NONE(val)) n = 0; else return PE_BAD_SET; switch(i) { case 0: tf.h = n; break; case 1: tf.m = n; break; case 2: if (IS_DECIMAL(val)) { f = VAL_DECIMAL(val); if (f < 0.0) Trap_Range_DEAD_END(val); tf.s = (REBINT)f; tf.n = (REBINT)((f - tf.s) * SEC_SEC); } else { tf.s = n; tf.n = 0; } break; default: return PE_BAD_SELECT; } VAL_TIME(pvs->value) = Join_Time(&tf, FALSE); return PE_OK; } }
/* * Used when converting result from a query */ int db_postgres_val2str(const db_con_t* _con, const db_val_t* _v, char* _s, int* _len) { int l, ret; int pgret; char *tmp_s; size_t tmp_len; char* old_s; if ((!_v) || (!_s) || (!_len) || (!*_len)) { LM_ERR("invalid parameter value\n"); return -1; } if (VAL_NULL(_v)) { if ( *_len < (l=(int)sizeof("NULL")-1)) { LM_ERR("buffer too short to print NULL\n"); return -1; } memcpy(_s, "NULL", l); *_len = l; return 0; } switch(VAL_TYPE(_v)) { case DB_INT: if (db_int2str(VAL_INT(_v), _s, _len) < 0) { LM_ERR("failed to convert string to int\n"); return -2; } else { return 0; } break; case DB_BIGINT: if (db_bigint2str(VAL_BIGINT(_v), _s, _len) < 0) { LM_ERR("failed to convert string to big int\n"); return -2; } else { return 0; } break; case DB_BITMAP: if (db_int2str(VAL_BITMAP(_v), _s, _len) < 0) { LM_ERR("failed to convert string to int\n"); return -3; } else { return 0; } break; case DB_DOUBLE: if (db_double2str(VAL_DOUBLE(_v), _s, _len) < 0) { LM_ERR("failed to convert string to double\n"); return -3; } else { return 0; } break; case DB_STRING: l = strlen(VAL_STRING(_v)); if (*_len < (l * 2 + 3)) { LM_ERR("destination STRING buffer too short (have %d, need %d)\n", *_len, l * 2 + 3); return -4; } else { old_s = _s; *_s++ = '\''; ret = PQescapeStringConn(CON_CONNECTION(_con), _s, VAL_STRING(_v), l, &pgret); if(pgret!=0) { LM_ERR("PQescapeStringConn failed\n"); return -4; } LM_DBG("PQescapeStringConn: in: %d chars," " out: %d chars\n", l, ret); _s += ret; *_s++ = '\''; *_s = '\0'; /* FIXME */ *_len = _s - old_s; return 0; } break; case DB_STR: l = VAL_STR(_v).len; if (*_len < (l * 2 + 3)) { LM_ERR("destination STR buffer too short (have %d, need %d)\n", *_len, l * 2 + 3); return -5; } else { old_s = _s; *_s++ = '\''; ret = PQescapeStringConn(CON_CONNECTION(_con), _s, VAL_STRING(_v), l, &pgret); if(pgret!=0) { LM_ERR("PQescapeStringConn failed \n"); return -5; } LM_DBG("PQescapeStringConn: in: %d chars, out: %d chars\n", l, ret); _s += ret; *_s++ = '\''; *_s = '\0'; /* FIXME */ *_len = _s - old_s; return 0; } break; case DB_DATETIME: if (db_time2str(VAL_TIME(_v), _s, _len) < 0) { LM_ERR("failed to convert string to time_t\n"); return -6; } else { return 0; } break; case DB_BLOB: l = VAL_BLOB(_v).len; /* this estimation is not always correct, thus we need to check later again */ if (*_len < (l * 2 + 3)) { LM_ERR("destination BLOB buffer too short (have %d, need %d)\n", *_len, l * 2 + 3); return -7; } else { *_s++ = '\''; tmp_s = (char*)PQescapeByteaConn(CON_CONNECTION(_con), (unsigned char*)VAL_STRING(_v), (size_t)l, (size_t*)&tmp_len); if(tmp_s==NULL) { LM_ERR("PQescapeBytea failed\n"); return -7; } if (tmp_len > *_len) { LM_ERR("escaped result too long\n"); return -7; } memcpy(_s, tmp_s, tmp_len); PQfreemem(tmp_s); tmp_len = strlen(_s); *(_s + tmp_len) = '\''; *(_s + tmp_len + 1) = '\0'; *_len = tmp_len + 2; return 0; } break; default: LM_DBG("unknown data type\n"); return -7; } }
/* * Convert str to db value, does not copy strings */ int db_mysql_str2val(const db_type_t _t, db_val_t* _v, const char* _s, const int _l) { static str dummy_string = {"", 0}; if (!_v) { LM_ERR("invalid parameter value\n"); return -1; } if (!_s) { memset(_v, 0, sizeof(db_val_t)); /* Initialize the string pointers to a dummy empty * string so that we do not crash when the NULL flag * is set but the module does not check it properly */ VAL_STRING(_v) = dummy_string.s; VAL_STR(_v) = dummy_string; VAL_BLOB(_v) = dummy_string; VAL_TYPE(_v) = _t; VAL_NULL(_v) = 1; return 0; } VAL_NULL(_v) = 0; switch(_t) { case DB_INT: LM_DBG("converting INT [%s]\n", _s); if (db_str2int(_s, &VAL_INT(_v)) < 0) { LM_ERR("error while converting integer value from string\n"); return -2; } else { VAL_TYPE(_v) = DB_INT; return 0; } break; case DB_BIGINT: LM_DBG("converting INT BIG[%s]\n", _s); if (db_str2bigint(_s, &VAL_BIGINT(_v)) < 0) { LM_ERR("error while converting big integer value from string\n"); return -2; } else { VAL_TYPE(_v) = DB_BIGINT; return 0; } break; case DB_BITMAP: LM_DBG("converting BITMAP [%s]\n", _s); if (db_str2int(_s, &VAL_INT(_v)) < 0) { LM_ERR("error while converting bitmap value from string\n"); return -3; } else { VAL_TYPE(_v) = DB_BITMAP; return 0; } break; case DB_DOUBLE: LM_DBG("converting DOUBLE [%s]\n", _s); if (db_str2double(_s, &VAL_DOUBLE(_v)) < 0) { LM_ERR("error while converting double value from string\n"); return -4; } else { VAL_TYPE(_v) = DB_DOUBLE; return 0; } break; case DB_STRING: LM_DBG("converting STRING [%s]\n", _s); VAL_STRING(_v) = _s; VAL_TYPE(_v) = DB_STRING; return 0; case DB_STR: LM_DBG("converting STR [%.*s]\n", _l, _s); VAL_STR(_v).s = (char*)_s; VAL_STR(_v).len = _l; VAL_TYPE(_v) = DB_STR; return 0; case DB_DATETIME: LM_DBG("converting DATETIME [%s]\n", _s); if (db_str2time(_s, &VAL_TIME(_v)) < 0) { LM_ERR("error while converting datetime value from string\n"); return -5; } else { VAL_TYPE(_v) = DB_DATETIME; return 0; } break; case DB_BLOB: LM_DBG("converting BLOB [%.*s]\n", _l, _s); VAL_BLOB(_v).s = (char*)_s; VAL_BLOB(_v).len = _l; VAL_TYPE(_v) = DB_BLOB; return 0; } return -6; }
int db_mysql_val2bind(const db_val_t* v, MYSQL_BIND *binds, unsigned int i) { struct tm *t; MYSQL_TIME *mt; if (VAL_NULL(v)) { *(binds[i].is_null) = 1; *(binds[i].length) = 0; binds[i].buffer= NULL; switch(VAL_TYPE(v)) { case DB_INT: binds[i].buffer_type= MYSQL_TYPE_LONG; break; case DB_BIGINT: binds[i].buffer_type= MYSQL_TYPE_LONGLONG; break; case DB_BITMAP: binds[i].buffer_type= MYSQL_TYPE_LONG; break; case DB_DOUBLE: binds[i].buffer_type= MYSQL_TYPE_DOUBLE; break; case DB_STRING: binds[i].buffer_type= MYSQL_TYPE_STRING; break; case DB_STR: binds[i].buffer_type= MYSQL_TYPE_STRING; break; case DB_DATETIME: binds[i].buffer_type= MYSQL_TYPE_DATETIME; break; case DB_BLOB: binds[i].buffer_type= MYSQL_TYPE_BLOB; break; default: LM_ERR("unknown NULL data type (%d)\n",VAL_TYPE(v)); return -10; } return 0; } else { *(binds[i].is_null) = 0; } switch(VAL_TYPE(v)) { case DB_INT: binds[i].buffer_type= MYSQL_TYPE_LONG; binds[i].buffer= (char*)&(VAL_INT(v)); *binds[i].length= sizeof(VAL_INT(v)); break; case DB_BIGINT: binds[i].buffer_type= MYSQL_TYPE_LONGLONG; binds[i].buffer= (char*)&(VAL_BIGINT(v)); *binds[i].length= sizeof(VAL_BIGINT(v)); break; case DB_BITMAP: binds[i].buffer_type= MYSQL_TYPE_LONG; binds[i].buffer= (char*)&(VAL_BITMAP(v)); *binds[i].length= sizeof(VAL_BITMAP(v)); break; case DB_DOUBLE: binds[i].buffer_type= MYSQL_TYPE_DOUBLE; binds[i].buffer= (char*)&(VAL_DOUBLE(v)); *binds[i].length= sizeof(VAL_DOUBLE(v)); break; case DB_STRING: binds[i].buffer_type= MYSQL_TYPE_STRING; binds[i].buffer= (char*)VAL_STRING(v); *binds[i].length= strlen(VAL_STRING(v)); break; case DB_STR: binds[i].buffer_type= MYSQL_TYPE_STRING; binds[i].buffer= VAL_STR(v).s; *binds[i].length= VAL_STR(v).len; break; case DB_DATETIME: binds[i].buffer_type= MYSQL_TYPE_DATETIME; t = localtime( &VAL_TIME(v) ); mt = (MYSQL_TIME*)binds[i].buffer; mt->year = 1900 + t->tm_year; mt->month = (t->tm_mon)+1; mt->day = t->tm_mday; mt->hour = t->tm_hour; mt->minute = t->tm_min; mt->second = t->tm_sec; *binds[i].length= sizeof(MYSQL_TIME); break; case DB_BLOB: binds[i].buffer_type= MYSQL_TYPE_BLOB; binds[i].buffer= VAL_BLOB(v).s; *binds[i].length= VAL_BLOB(v).len; break; default: LM_ERR("unknown data type (%d)\n",VAL_TYPE(v)); return -9; } LM_DBG("added val (%d): len=%ld; type=%d; is_null=%d\n", i, *(binds[i].length), binds[i].buffer_type, *(binds[i].is_null)); return 0; }
*/ REBI64 Make_Time(REBVAL *val) /* ** Returns NO_TIME if error. ** ***********************************************************************/ { REBI64 secs = 0; if (IS_TIME(val)) { secs = VAL_TIME(val); } else if (IS_STRING(val)) { REBYTE *bp; REBCNT len; bp = Qualify_String(val, 30, &len, FALSE); // can trap, ret diff str if (!Scan_Time(bp, len, val)) goto no_time; secs = VAL_TIME(val); } else if (IS_INTEGER(val)) { if (VAL_INT64(val) < -MAX_SECONDS || VAL_INT64(val) > MAX_SECONDS) Trap_Range_DEAD_END(val); secs = VAL_INT64(val) * SEC_SEC; } else if (IS_DECIMAL(val)) { if (VAL_DECIMAL(val) < (REBDEC)(-MAX_SECONDS) || VAL_DECIMAL(val) > (REBDEC)MAX_SECONDS) Trap_Range_DEAD_END(val); secs = DEC_TO_SECS(VAL_DECIMAL(val)); } else if (ANY_BLOCK(val) && VAL_BLK_LEN(val) <= 3) { REBFLG neg = FALSE; REBI64 i; val = VAL_BLK_DATA(val); if (!IS_INTEGER(val)) goto no_time; i = Int32(val); if (i < 0) i = -i, neg = TRUE; secs = i * 3600; if (secs > MAX_SECONDS) goto no_time; if (NOT_END(++val)) { if (!IS_INTEGER(val)) goto no_time; if ((i = Int32(val)) < 0) goto no_time; secs += i * 60; if (secs > MAX_SECONDS) goto no_time; if (NOT_END(++val)) { if (IS_INTEGER(val)) { if ((i = Int32(val)) < 0) goto no_time; secs += i; if (secs > MAX_SECONDS) goto no_time; } else if (IS_DECIMAL(val)) { if (secs + (REBI64)VAL_DECIMAL(val) + 1 > MAX_SECONDS) goto no_time; // added in below } else goto no_time; } } secs *= SEC_SEC; if (IS_DECIMAL(val)) secs += DEC_TO_SECS(VAL_DECIMAL(val)); if (neg) secs = -secs; } else no_time: return NO_TIME; return secs; }
/* * Convert a str to a db value, does not copy strings * The postgresql module uses a custom escape function for BLOBs, * so the common db_str2val function from db_ut.h could not used. * If the _s is linked in the db_val result, it will be returned zero */ int pg_str2val(db_type_t _t, db_val_t* _v, char* _s, int _l) { static str dummy_string = {"", 0}; #ifdef PARANOID if (!_v) { LM_ERR("db_val_t parameter cannot be NULL\n"); } #endif if (!_s) { memset(_v, 0, sizeof(db_val_t)); /* Initialize the string pointers to a dummy empty * string so that we do not crash when the NULL flag * is set but the module does not check it properly */ VAL_STRING(_v) = dummy_string.s; VAL_STR(_v) = dummy_string; VAL_BLOB(_v) = dummy_string; VAL_TYPE(_v) = _t; VAL_NULL(_v) = 1; return 0; } VAL_NULL(_v) = 0; switch(_t) { case DB_INT: LM_DBG("converting INT [%s]\n", _s); if (db_str2int(_s, &VAL_INT(_v)) < 0) { LM_ERR("failed to convert INT value from string\n"); return -2; } else { VAL_TYPE(_v) = DB_INT; return 0; } break; case DB_BITMAP: LM_DBG("converting BITMAP [%s]\n", _s); if (db_str2int(_s, &VAL_INT(_v)) < 0) { LM_ERR("failed to convert BITMAP value from string\n"); return -3; } else { VAL_TYPE(_v) = DB_BITMAP; return 0; } break; case DB_DOUBLE: LM_DBG("converting DOUBLE [%s]\n", _s); if (db_str2double(_s, &VAL_DOUBLE(_v)) < 0) { LM_ERR("failed to convert DOUBLE value from string\n"); return -4; } else { VAL_TYPE(_v) = DB_DOUBLE; return 0; } break; case DB_STRING: LM_DBG("converting STRING [%s]\n", _s); VAL_STRING(_v) = _s; VAL_TYPE(_v) = DB_STRING; return 0; case DB_STR: LM_DBG("converting STR [%s]\n", _s); VAL_STR(_v).s = (char*)_s; VAL_STR(_v).len = _l; VAL_TYPE(_v) = DB_STR; _s = 0; return 0; case DB_DATETIME: LM_DBG("converting DATETIME [%s]\n", _s); if (db_str2time(_s, &VAL_TIME(_v)) < 0) { LM_ERR("failed to convert datetime\n"); return -5; } else { VAL_TYPE(_v) = DB_DATETIME; return 0; } break; case DB_BLOB: LM_DBG("converting BLOB [%s]\n", _s); /* PQunescapeBytea: Converts a string representation of binary data * into binary data — the reverse of PQescapeBytea. * This is needed when retrieving bytea data in text format, * but not when retrieving it in binary format. */ VAL_BLOB(_v).s = (char*)PQunescapeBytea((unsigned char*)_s, (size_t*)(void*)&(VAL_BLOB(_v).len) ); VAL_TYPE(_v) = DB_BLOB; LM_DBG("got blob len %d\n", _l); return 0; } return -6; }
/** * Does not copy strings */ int bdb_str2val(db_type_t _t, db_val_t* _v, char* _s, int _l) { static str dummy_string = {"", 0}; if(!_s) { memset(_v, 0, sizeof(db_val_t)); /* Initialize the string pointers to a dummy empty * string so that we do not crash when the NULL flag * is set but the module does not check it properly */ VAL_STRING(_v) = dummy_string.s; VAL_STR(_v) = dummy_string; VAL_BLOB(_v) = dummy_string; VAL_TYPE(_v) = _t; VAL_NULL(_v) = 1; return 0; } VAL_NULL(_v) = 0; switch(_t) { case DB1_INT: if (db_str2int(_s, &VAL_INT(_v)) < 0) { LM_ERR("Error while converting INT value from string\n"); return -2; } else { VAL_TYPE(_v) = DB1_INT; return 0; } break; case DB1_BIGINT: LM_ERR("BIGINT not supported"); return -1; case DB1_BITMAP: if (db_str2int(_s, &VAL_INT(_v)) < 0) { LM_ERR("Error while converting BITMAP value from string\n"); return -3; } else { VAL_TYPE(_v) = DB1_BITMAP; return 0; } break; case DB1_DOUBLE: if (db_str2double(_s, &VAL_DOUBLE(_v)) < 0) { LM_ERR("Error while converting DOUBLE value from string\n"); return -4; } else { VAL_TYPE(_v) = DB1_DOUBLE; return 0; } break; case DB1_STRING: VAL_STRING(_v) = _s; VAL_TYPE(_v) = DB1_STRING; VAL_FREE(_v) = 1; if( strlen(_s)==4 && !strncasecmp(_s, "NULL", 4) ) VAL_NULL(_v) = 1; return 0; case DB1_STR: VAL_STR(_v).s = (char*)_s; VAL_STR(_v).len = _l; VAL_TYPE(_v) = DB1_STR; VAL_FREE(_v) = 1; if( strlen(_s)==4 && !strncasecmp(_s, "NULL", 4) ) VAL_NULL(_v) = 1; return 0; case DB1_DATETIME: if (db_str2time(_s, &VAL_TIME(_v)) < 0) { LM_ERR("Error converting datetime\n"); return -5; } else { VAL_TYPE(_v) = DB1_DATETIME; return 0; } break; case DB1_BLOB: VAL_BLOB(_v).s = _s; VAL_TYPE(_v) = DB1_BLOB; LM_DBG("got blob len %d\n", _l); return 0; } return -6; }
/* * Used when converting result from a query */ int km_bdb_val2str(db_val_t* _v, char* _s, int* _len) { int l; if (VAL_NULL(_v)) { *_len = snprintf(_s, *_len, "NULL"); return 0; } switch(VAL_TYPE(_v)) { case DB1_INT: if (db_int2str(VAL_INT(_v), _s, _len) < 0) { LM_ERR("Error while converting int to string\n"); return -2; } else { LM_DBG("Converted int to string\n"); return 0; } break; case DB1_BITMAP: if (db_int2str(VAL_INT(_v), _s, _len) < 0) { LM_ERR("Error while converting bitmap to string\n"); return -3; } else { LM_DBG("Converted bitmap to string\n"); return 0; } break; case DB1_DOUBLE: if (db_double2str(VAL_DOUBLE(_v), _s, _len) < 0) { LM_ERR("Error while converting double to string\n"); return -3; } else { LM_DBG("Converted double to string\n"); return 0; } break; case DB1_STRING: l = strlen(VAL_STRING(_v)); if (*_len < l ) { LM_ERR("Destination buffer too short for string\n"); return -4; } else { LM_DBG("Converted string to string\n"); strncpy(_s, VAL_STRING(_v) , l); _s[l] = 0; *_len = l; return 0; } break; case DB1_STR: l = VAL_STR(_v).len; if (*_len < l) { LM_ERR("Destination buffer too short for str\n"); return -5; } else { LM_DBG("Converted str to string\n"); strncpy(_s, VAL_STR(_v).s , VAL_STR(_v).len); *_len = VAL_STR(_v).len; return 0; } break; case DB1_DATETIME: if (km_bdb_time2str(VAL_TIME(_v), _s, _len) < 0) { LM_ERR("Error while converting time_t to string\n"); return -6; } else { LM_DBG("Converted time_t to string\n"); return 0; } break; case DB1_BLOB: l = VAL_BLOB(_v).len; if (*_len < l) { LM_ERR("Destination buffer too short for blob\n"); return -7; } else { LM_DBG("Converting BLOB [%s]\n", _s); _s = VAL_BLOB(_v).s; *_len = 0; return -8; } break; default: LM_DBG("Unknown data type\n"); return -8; } }
/* * Called after val2str to realy binding */ int db_oracle_val2bind(bmap_t* _m, const db_val_t* _v, OCIDate* _o) { if (VAL_NULL(_v)) { _m->addr = NULL; _m->size = 0; _m->type = SQLT_NON; return 0; } switch (VAL_TYPE(_v)) { case DB1_INT: _m->addr = (int*)&VAL_INT(_v); _m->size = sizeof(VAL_INT(_v)); _m->type = SQLT_INT; break; case DB1_BIGINT: LM_ERR("BIGINT not supported"); return -1; case DB1_BITMAP: _m->addr = (unsigned*)&VAL_BITMAP(_v); _m->size = sizeof(VAL_BITMAP(_v)); _m->type = SQLT_UIN; break; case DB1_DOUBLE: _m->addr = (double*)&VAL_DOUBLE(_v); _m->size = sizeof(VAL_DOUBLE(_v)); _m->type = SQLT_FLT; break; case DB1_STRING: _m->addr = (char*)VAL_STRING(_v); _m->size = strlen(VAL_STRING(_v))+1; _m->type = SQLT_STR; break; case DB1_STR: { unsigned len = VAL_STR(_v).len; char *estr, *pstr = VAL_STR(_v).s; estr = (char*)memchr(pstr, 0, len); if (estr) { LM_WARN("truncate STR len from %u to: '%s'\n", len, pstr); len = (unsigned)(estr - pstr) + 1; } _m->size = len; _m->addr = pstr; _m->type = SQLT_CHR; } break; case DB1_DATETIME: { struct tm* tm = localtime(&VAL_TIME(_v)); if (tm->tm_sec == 60) --tm->tm_sec; OCIDateSetDate(_o, (ub2)(tm->tm_year + 1900), (ub1)(tm->tm_mon + 1), (ub1)tm->tm_mday); OCIDateSetTime(_o, (ub1)tm->tm_hour, (ub1)tm->tm_min, (ub1)tm->tm_sec); _m->addr = _o; _m->size = sizeof(*_o); _m->type = SQLT_ODT; } break; case DB1_BLOB: _m->addr = VAL_BLOB(_v).s; _m->size = VAL_BLOB(_v).len; _m->type = SQLT_CLOB; break; default: LM_ERR("unknown data type\n"); return -1; } return 0; }