/*
* call-seq:
* OCI8::Math.tanh() -> oranumber
*
* Computes the hyperbolic tangent of <i>x</i> (expressed in
* radians).
*/
static VALUE omath_tanh(VALUE obj, VALUE num)
{
OCIError *errhp = oci8_errhp;
OCINumber n;
OCINumber r;
chkerr(OCINumberHypTan(errhp, TO_OCINUM(&n, num, errhp), &r));
return oci8_make_ocinumber(&r, errhp);
}
/* construct an ruby object(OCI::Number) from C structure (OCINumber). */
VALUE oci8_make_ocinumber(OCINumber *s, OCIError *errhp)
{
VALUE obj;
OCINumber *d;
obj = Data_Make_Struct(cOCINumber, OCINumber, NULL, xfree, d);
chkerr(OCINumberAssign(errhp, s, d));
return obj;
}
int redis_flush(void)
{
redisReply *reply = (redisReply*) redisCommand(rctx, "FLUSHDB");
if (chkerr(reply)) {
return -1;
}
freeReplyObject(reply);
return 0;
}
/*
* call-seq:
* OCI8::Math.tan(x) -> oranumber
*
* Returns the tangent of <i>x</i> (expressed in radians).
*/
static VALUE omath_tan(VALUE obj, VALUE radian)
{
OCIError *errhp = oci8_errhp;
OCINumber r;
OCINumber rv;
chkerr(OCINumberTan(errhp, TO_OCINUM(&r, radian, errhp), &rv));
return oci8_make_ocinumber(&rv, errhp);
}
gnutls_x509_crt_t *gnutls::credentials::callbackObj
::init_certs(std::list<x509::crt> &x509_cert)
{
gnutls_x509_crt_t *certs=(gnutls_x509_crt_t *)
gnutls_malloc(sizeof(gnutls_x509_crt_t) *
x509_cert.size());
size_t n=0;
try {
std::list<x509::crt>::iterator
ccb=x509_cert.begin(),
cce=x509_cert.end();
while (ccb != cce)
{
datum_t d=(*ccb)->export_cert(GNUTLS_X509_FMT_DER);
++ccb;
gnutls_datum_t dd;
dd.data=&*d->begin();
dd.size=d->size();
chkerr(gnutls_x509_crt_init(&certs[n]),
"gnutls_x509_crt_init");
++n;
chkerr(gnutls_x509_crt_import(certs[n-1], &dd,
GNUTLS_X509_FMT_DER),
"gnutls_x509_crt_import");
}
}
catch (...)
{
while (n)
{
gnutls_x509_crt_deinit(certs[--n]);
}
gnutls_free(certs);
throw;
}
return certs;
}
int redis_delconf(redisContext* rctx, const char *name)
{
assert(rctx);
redisReply *reply = redisCommand(rctx, "DEL %s", name);
if (chkerr(rctx, reply)) {
return ZMAP_REDIS_ERROR;
}
freeReplyObject(reply);
return 0;
}
int redis_flush(redisContext* rctx)
{
assert(rctx);
redisReply *reply = redisCommand(rctx, "FLUSHDB");
if (chkerr(rctx, reply)) {
return ZMAP_REDIS_ERROR;
}
freeReplyObject(reply);
return 0;
}
/*
* call-seq:
* onum.truncate -> integer
* onum.truncate(decplace) -> oranumber
*
* Truncates <i>onum</i> to the <code>Integer</code> when no argument.
* Truncates <i>onum</i> to a specified decimal place <i>decplace</i> when one argument.
*/
static VALUE onum_trunc(int argc, VALUE *argv, VALUE self)
{
OCIError *errhp = oci8_errhp;
VALUE decplace;
OCINumber r;
rb_scan_args(argc, argv, "01", &decplace /* 0 */);
chkerr(OCINumberTrunc(errhp, _NUMBER(self), NIL_P(decplace) ? 0 : NUM2INT(decplace), &r));
return oci8_make_ocinumber(&r, errhp);
}
int redis_delconf(const char *name)
{
assert(rctx);
redisReply *reply = (redisReply*) redisCommand(rctx, "DEL %s", name);
if (chkerr(reply)) {
return -1;
}
freeReplyObject(reply);
return 0;
}
int redis_setconf(redisContext* rctx, const char *name, char *value)
{
assert(rctx);
redisReply *reply = redisCommand(rctx, "SET %s %s", name, value);
if (chkerr(rctx, reply)) {
return ZMAP_REDIS_ERROR;
}
freeReplyObject(reply);
return 0;
}
/*
* call-seq:
* OCI8::Math.asin(x) -> oranumber
*
* Computes the arc sine of <i>x</i>. Returns 0..PI.
*/
static VALUE omath_asin(VALUE obj, VALUE num)
{
OCIError *errhp = oci8_errhp;
OCINumber n;
OCINumber r;
sword sign;
set_oci_number_from_num(&n, num, 1, errhp);
/* check upper bound */
chkerr(OCINumberCmp(errhp, &n, &const_p1, &sign));
if (sign > 0)
rb_raise(rb_eRangeError, "out of range for asin");
/* check lower bound */
chkerr(OCINumberCmp(errhp, &n, &const_m1, &sign));
if (sign < 0)
rb_raise(rb_eRangeError, "out of range for asin");
/* asin */
chkerr(OCINumberArcSin(errhp, &n, &r));
return oci8_make_ocinumber(&r, errhp);
}
int redis_existconf(redisContext* rctx, const char *name)
{
assert(rctx);
redisReply *reply = redisCommand(rctx, "EXISTS %s", name);
if (chkerr(rctx, reply)) {
return ZMAP_REDIS_ERROR;
}
int v = reply->integer;
freeReplyObject(reply);
return v;
}
int redis_setconf(const char *name, char *value)
{
assert(rctx);
redisReply *reply = (redisReply*) redisCommand(rctx, "SET %s %s",
name, value);
if (chkerr(reply)) {
return -1;
}
freeReplyObject(reply);
return 0;
}
int redis_existconf(const char *name)
{
assert(rctx);
redisReply *reply = (redisReply*) redisCommand(rctx, "EXISTS %s", name);
if (chkerr(reply)) {
return -1;
}
int v = reply->integer;
freeReplyObject(reply);
return v;
}
int redis_getconf(const char *name, char *buf, size_t maxlen)
{
assert(rctx);
redisReply *reply = (redisReply*) redisCommand(rctx, "GET %s", name);
if (chkerr(reply)) {
return -1;
}
strncpy(buf, reply->str, maxlen);
freeReplyObject(reply);
return 0;
}
static int redis_push_one(redisContext *rctx, char *queuename, void *buf,
size_t len, const char *cmd)
{
assert(rctx);
redisReply *reply = redisCommand(rctx, "%s %s %b", cmd, queuename, buf, len);
if (chkerr(rctx, reply)) {
return ZMAP_REDIS_ERROR;
}
freeReplyObject(reply);
return ZMAP_REDIS_SUCCESS;
}
int redis_getconf(redisContext* rctx, const char *name, char *buf, size_t maxlen)
{
assert(rctx);
redisReply *reply = redisCommand(rctx, "GET %s", name);
if (chkerr(rctx, reply)) {
return ZMAP_REDIS_ERROR;
}
strncpy(buf, reply->str, maxlen - 1);
buf[maxlen - 1] = '\0';
freeReplyObject(reply);
return 0;
}
runpcs(runmode,execsig)
{
INT rc;
REG BKPTR bkpt;
IF adrflg THEN userpc=dot; FI
printf("%s: running\n", symfil);
WHILE --loopcnt>=0
DO
#ifdef DEBUG
printf("\ncontinue %x %d\n",userpc,execsig);
#endif
IF runmode==SINGLE
THEN delbp(); /* hardware handles single-stepping */
ELSE /* continuing from a breakpoint is hard */
IF bkpt=scanbkpt(userpc)
THEN execbkpt(bkpt,execsig); execsig=0;
FI
setbp();
FI
ptrace(runmode,pid,userpc,execsig);
bpwait(); chkerr(); execsig=0; delbp(); readregs();
IF signo==0
ANDF runmode != SINGLE
#ifdef mc68000
ANDF (bkpt=scanbkpt(userpc - 2)) /* argh */
#else
ANDF (bkpt=scanbkpt(userpc))
#endif
THEN /* stopped by BPT instruction */
#ifdef DEBUG
printf("\n BPT code; '%s'%o'%o'%d",
bkpt->comm,bkpt->comm[0],EOR,bkpt->flag);
#endif
dot=bkpt->loc;
userpc = dot;
*(ADDR *)(((ADDR)&u)+PC-getradj(1)) = userpc;
IF bkpt->flag==BKPTEXEC
ORF ((bkpt->flag=BKPTEXEC)
ANDF bkpt->comm[0]!=EOR
ANDF command(bkpt->comm,':')
ANDF --bkpt->count)
THEN execbkpt(bkpt,execsig); execsig=0; loopcnt++;
ELSE bkpt->count=bkpt->initcnt; rc=1;
FI
ELSE execsig=signo; rc=0;
FI
OD
return(rc);
}
/* Converts to BigDecimal via number in scientific notation */
static VALUE onum_to_d_real(OCINumber *num, OCIError *errhp)
{
char buf[64];
ub4 buf_size = sizeof(buf);
const char *fmt = "FM9.99999999999999999999999999999999999999EEEE";
if (!cBigDecimal) {
rb_require("bigdecimal");
cBigDecimal = rb_const_get(rb_cObject, id_BigDecimal);
}
chkerr(OCINumberToText(errhp, num, (const oratext *)fmt, strlen(fmt),
NULL, 0, &buf_size, TO_ORATEXT(buf)));
return rb_funcall(rb_cObject, id_BigDecimal, 1, rb_usascii_str_new(buf, buf_size));
}
/*
* call-seq:
* onum.round -> integer
* onum.round(decplace) -> oranumber
*
* Rounds <i>onum</i> to the nearest <code>Integer</code> when no argument.
* Rounds <i>onum</i> to a specified decimal place <i>decplace</i> when one argument.
*
* OraNumber.new(1.234).round(1) #=> 1.2
* OraNumber.new(1.234).round(2) #=> 1.23
* OraNumber.new(1.234).round(3) #=> 1.234
*/
static VALUE onum_round(int argc, VALUE *argv, VALUE self)
{
OCIError *errhp = oci8_errhp;
VALUE decplace;
OCINumber r;
rb_scan_args(argc, argv, "01", &decplace /* 0 */);
chkerr(OCINumberRound(errhp, _NUMBER(self), NIL_P(decplace) ? 0 : NUM2INT(decplace), &r));
if (argc == 0) {
return oci8_make_integer(&r, errhp);
} else {
return oci8_make_ocinumber(&r, errhp);
}
}
VALUE oci8_make_ociinterval_ds(OCIInterval *s)
{
sb4 day;
sb4 hour;
sb4 minute;
sb4 sec;
sb4 fsec;
chkerr(OCIIntervalGetDaySecond(oci8_envhp, oci8_errhp, &day, &hour, &minute, &sec, &fsec, s));
return rb_ary_new3(5,
INT2FIX(day), INT2FIX(hour),
INT2FIX(minute), INT2FIX(sec),
INT2FIX(fsec));
}
int main(void) {
char ***l1 = NULL, *fv[3] ,dir[50] ,c;
int vc, bg, id, p[2], d;
signal(SIGINT, SIG_IGN); signal(SIGQUIT,SIG_IGN);
while (1) {
getcwd(dir,50); write(1,dir,strlen(dir)); write(1," $ ",d = bg = 3);
for (;bg; fv[bg] = NULL) realloc(fv[--bg],0); size(l1,4,0,NULL);
for (vc = p[0] = 0; read(0,&c,1) && (c != '\n');)
switch(c) {
case '<': d = 0; break;
case '>': d = 1; break;
case '|': if (l2) {vc++; p[0] = 0;} d = 3; break;
case '&': if (d < 3) d++; else bg = 1; break;
case ' ': if (d < 3) {if (fv[d]) d = 3;} else if (l2 && l3) p[0]++; break;
default: if (d < 3) {if (!fv[d]) size(fv[d],1,0,'\0');
size(fv[d],(id=strlen(fv[d]))+2,id,c); fv[d][id+1]='\0';}
else { if (!l2) {size(l1,vc*4+8,vc+1,NULL); size(l2,4,0,NULL);}
if (!l3) {size(l2,p[0]*4+8,p[0]+1,NULL); size(l3,1,0,'\0');}
size(l3,(id=strlen(l3))+2,id,c); l3[id+1] = '\0';}}
for (vc = 0; l2;) {
if (!vc) d = dup(0);
if (l1[vc+1]) chkerr(pipe(p),"pipe");
if (!strcmp(l2[0],"exit")) exit(0);
if (!strcmp(l2[0],"cd")) {if (chdir(l2[1]) < 0) chdir(getenv("HOME"));}
else {if (!(id = fork())) {
if (fv[0] && !vc) redir(0,O_RDONLY) else mvdesc(0,d);
if (fv[1]) redir(1,O_CREAT|O_WRONLY|O_TRUNC);
if (fv[2]) redir(2,O_CREAT|O_WRONLY|O_TRUNC);
if (l1[vc+1]) {mvdesc(1,p[1]); close(p[0]);}
if (!bg) {signal(SIGINT,SIG_DFL); signal(SIGQUIT,SIG_DFL);}
chkerr(execvp(l2[0],l2),"exec");}
if (!l1[vc+1] && !bg) while (wait(NULL) != id);}
for (id = 0; l2[id]; realloc(l2[id++],0)); realloc(l2,0);
close(d); if (l1[++vc]) {d = dup(p[0]); close(p[0]); close(p[1]);}}}}
OCIInterval *oci8_set_ociinterval_ym(OCIInterval *intvl, VALUE val)
{
sb4 year;
sb4 month;
Check_Type(val, T_ARRAY);
if (RARRAY_LEN(val) != 2) {
rb_raise(rb_eRuntimeError, "invalid array size %ld", RARRAY_LEN(val));
}
year = NUM2INT(RARRAY_AREF(val, 0));
month = NUM2INT(RARRAY_AREF(val, 1));
chkerr(OCIIntervalSetYearMonth(oci8_envhp, oci8_errhp,
year, month, intvl));
return intvl;
}
/*
* call-seq:
* onum.to_char(fmt = nil, nls_params = nil) -> string
*
* Returns a string containing a representation of self.
* <i>fmt</i> and <i>nls_params</i> are same meanings with
* <code>TO_CHAR</code> of Oracle function.
*/
static VALUE onum_to_char(int argc, VALUE *argv, VALUE self)
{
OCIError *errhp = oci8_errhp;
VALUE fmt;
VALUE nls_params;
char buf[512];
ub4 buf_size = sizeof(buf);
oratext *fmt_ptr;
oratext *nls_params_ptr;
ub4 fmt_len;
ub4 nls_params_len;
sword rv;
rb_scan_args(argc, argv, "02", &fmt /* nil */, &nls_params /* nil */);
if (NIL_P(fmt)) {
rv = oranumber_to_str(_NUMBER(self), buf, sizeof(buf));
if (rv > 0) {
return rb_usascii_str_new(buf, rv);
}
oranumber_dump(_NUMBER(self), buf);
rb_raise(eOCIException, "Invalid internal number format: %s", buf);
}
StringValue(fmt);
fmt_ptr = RSTRING_ORATEXT(fmt);
fmt_len = RSTRING_LEN(fmt);
if (NIL_P(nls_params)) {
nls_params_ptr = NULL;
nls_params_len = 0;
} else {
StringValue(nls_params);
nls_params_ptr = RSTRING_ORATEXT(nls_params);
nls_params_len = RSTRING_LEN(nls_params);
}
rv = OCINumberToText(errhp, _NUMBER(self),
fmt_ptr, fmt_len, nls_params_ptr, nls_params_len,
&buf_size, TO_ORATEXT(buf));
if (rv == OCI_ERROR) {
sb4 errcode;
OCIErrorGet(errhp, 1, NULL, &errcode, NULL, 0, OCI_HTYPE_ERROR);
if (errcode == 22065) {
/* OCI-22065: number to text translation for the given format causes overflow */
if (NIL_P(fmt)) /* implicit conversion */
return rb_usascii_str_new_cstr("overflow");
}
chkerr(rv);
}
return rb_usascii_str_new(buf, buf_size);
}
void iostream::switch_mode( void )
{
// return immediately if there's an error
if ( chkerr() ) return;
if ( mode == 0 ) {
// WARNING: when switching from reading to writing, information might be lost forever
switch ( srct ) {
case 0:
fclose( fptr );
fptr = fopen( ( char* ) source, "wb" );
break;
case 1:
case 2:
delete( mrdr );
if ( free_mem_sw )
free( source ); // see? I've told you so :-)
mwrt = new abytewriter( srcs );
break;
default:
break;
}
mode = 1;
}
else {
// switching from writing to reading is a bit more complicated
switch ( srct ) {
case 0:
fflush( fptr );
fclose( fptr );
fptr = fopen( ( char* ) source, "rb" );
break;
case 1:
case 2:
source = mwrt->getptr();
srcs = mwrt->getpos();
delete( mwrt );
mrdr = new abytereader( ( unsigned char* ) source, srcs );
free_mem_sw = true;
break;
default:
break;
}
mode = 0;
}
}
/*
* call-seq:
* onum <=> other -> -1, 0, +1
*
* Returns -1, 0, or +1 depending on whether <i>onum</i> is less than,
* equal to, or greater than <i>other</i>. This is the basis for the
* tests in <code>Comparable</code>.
*/
static VALUE onum_cmp(VALUE lhs, VALUE rhs)
{
OCIError *errhp = oci8_errhp;
OCINumber n;
sword r;
/* change to OCINumber */
if (!set_oci_number_from_num(&n, rhs, 0, errhp))
return rb_num_coerce_cmp(lhs, rhs, id_cmp);
/* compare */
chkerr(OCINumberCmp(errhp, _NUMBER(lhs), &n, &r));
if (r > 0) {
return INT2FIX(1);
} else if (r == 0) {
return INT2FIX(0);
} else {
return INT2FIX(-1);
}
}
/* fill C structure (OCINumber) from a string. */
static void set_oci_number_from_str(OCINumber *result, VALUE str, VALUE fmt, VALUE nls_params, OCIError *errhp)
{
oratext *fmt_ptr;
oratext *nls_params_ptr;
ub4 fmt_len;
ub4 nls_params_len;
StringValue(str);
/* set from string. */
if (NIL_P(fmt)) {
int rv = oranumber_from_str(result, RSTRING_PTR(str), RSTRING_LEN(str));
if (rv == ORANUMBER_SUCCESS) {
return; /* success */
} else {
const char *default_msg = NULL;
switch (rv) {
case ORANUMBER_INVALID_NUMBER:
default_msg = "invalid number";
break;
case ORANUMBER_NUMERIC_OVERFLOW:
default_msg = "numeric overflow";
break;
}
oci8_raise_by_msgno(rv, default_msg);
}
}
StringValue(fmt);
fmt_ptr = RSTRING_ORATEXT(fmt);
fmt_len = RSTRING_LEN(fmt);
if (NIL_P(nls_params)) {
nls_params_ptr = NULL;
nls_params_len = 0;
} else {
StringValue(nls_params);
nls_params_ptr = RSTRING_ORATEXT(nls_params);
nls_params_len = RSTRING_LEN(nls_params);
}
chkerr(OCINumberFromText(errhp,
RSTRING_ORATEXT(str), RSTRING_LEN(str),
fmt_ptr, fmt_len, nls_params_ptr, nls_params_len,
result));
}
int redis_pull(redisContext* rctx, char *redisqueuename, void *buf,
int maxload, size_t obj_size, int *numloaded, const char* cmd)
{
assert(rctx);
long elems_in_redis = redis_get_sizeof_list(rctx, redisqueuename);
long num_to_add = MIN(elems_in_redis, maxload);
log_debug("redis", "redis load called on %s. Transferring %li of %li elements "
"to in-memory queue.",
redisqueuename, num_to_add, elems_in_redis);
for (int i = 0; i < num_to_add; i++) {
redisAppendCommand(rctx, "%s %s", cmd, redisqueuename);
}
for (int i = 0; i < num_to_add; i++) {
redisReply *reply = NULL;
int rc = redisGetReply(rctx, (void **) &reply);
if (chkerr(rctx, reply)) {
return ZMAP_REDIS_ERROR;
}
if (rc != REDIS_OK || reply == NULL) {
log_error("redis", "unknown error, could not get reply");
if (reply) {
freeReplyObject(reply);
}
return ZMAP_REDIS_ERROR;
}
if (reply->type != REDIS_REPLY_STRING) {
log_error("redis", "unxpected reply type from redis");
freeReplyObject(reply);
return ZMAP_REDIS_ERROR;
}
if ((size_t) reply->len != obj_size) {
freeReplyObject(reply);
log_error("redis", "response object length mismatch");
return ZMAP_REDIS_ERROR;
}
memcpy((void*)((intptr_t)buf+i*obj_size), reply->str, obj_size);
freeReplyObject(reply);
*numloaded = i + 1;
}
return ZMAP_REDIS_SUCCESS;
}
static int redis_pull_one(redisContext *rctx, char *queuename, void **buf,
size_t *len, const char *cmd)
{
assert(rctx);
redisReply *reply = redisCommand(rctx, "%s %s", cmd, queuename);
if (chkerr(rctx, reply)) {
return ZMAP_REDIS_ERROR;
}
if (reply->type == REDIS_REPLY_NIL) {
freeReplyObject(reply);
return ZMAP_REDIS_EMPTY;
}
assert(reply->type == REDIS_REPLY_STRING);
*len = reply->len;
void *temp = (char*) malloc(*len);
assert(temp);
*buf = temp;
memcpy(temp, reply->str, *len);
freeReplyObject(reply);
return ZMAP_REDIS_SUCCESS;
}
OCIInterval *oci8_set_ociinterval_ds(OCIInterval *intvl, VALUE val)
{
sb4 day;
sb4 hour;
sb4 minute;
sb4 sec;
sb4 fsec;
Check_Type(val, T_ARRAY);
if (RARRAY_LEN(val) != 5) {
rb_raise(rb_eRuntimeError, "invalid array size %ld", RARRAY_LEN(val));
}
day = NUM2INT(RARRAY_AREF(val, 0));
hour = NUM2INT(RARRAY_AREF(val, 1));
minute = NUM2INT(RARRAY_AREF(val, 2));
sec = NUM2INT(RARRAY_AREF(val, 3));
fsec = NUM2INT(RARRAY_AREF(val, 4));
chkerr(OCIIntervalSetDaySecond(oci8_envhp, oci8_errhp,
day, hour, minute, sec, fsec, intvl));
return intvl;
}