static void oci8_bfile_get_name(VALUE self, VALUE *dir_alias_p, VALUE *filename_p)
{
int need_get = 0;
if (dir_alias_p != NULL) {
*dir_alias_p = rb_ivar_get(self, id_dir_alias);
if (NIL_P(*dir_alias_p))
need_get = 1;
}
if (filename_p != NULL) {
*filename_p = rb_ivar_get(self, id_filename);
if (NIL_P(*filename_p))
need_get = 1;
}
if (need_get) {
oci8_lob_t *lob = DATA_PTR(self);
char d_buf[31];
ub2 d_length = sizeof(d_buf);
char f_buf[256];
ub2 f_length = sizeof(f_buf);
VALUE dir_alias;
VALUE filename;
oci_lc(OCILobFileGetName(oci8_envhp, oci8_errhp, lob->base.hp.lob, TO_ORATEXT(d_buf), &d_length, TO_ORATEXT(f_buf), &f_length));
dir_alias = rb_external_str_new_with_enc(d_buf, d_length, oci8_encoding);
filename = rb_external_str_new_with_enc(f_buf, f_length, oci8_encoding);
rb_ivar_set(self, id_dir_alias, dir_alias);
rb_ivar_set(self, id_filename, filename);
if (dir_alias_p != NULL) {
*dir_alias_p = dir_alias;
}
if (filename_p != NULL) {
*filename_p = filename;
}
}
}
VALUE oci8_get_error_message(ub4 msgno, const char *default_msg)
{
char head[32];
size_t headsz;
const char *errmsg = NULL;
char msgbuf[64];
if (have_OCIMessageGet) {
if (msghp == NULL) {
chkerr(OCIMessageOpen(oci8_envhp, oci8_errhp, &msghp, TO_CONST_ORATEXT("rdbms"), TO_CONST_ORATEXT("ora"), OCI_DURATION_PROCESS));
}
errmsg = TO_CHARPTR(OCIMessageGet(msghp, msgno, NULL, 0));
}
if (errmsg == NULL) {
if (default_msg != NULL) {
errmsg = default_msg;
} else {
/* last resort */
snprintf(msgbuf, sizeof(msgbuf), "Message %u not found; product=rdbms; facility=ora", msgno);
errmsg = msgbuf;
}
}
headsz = snprintf(head, sizeof(head), "ORA-%05u: ", msgno);
return rb_str_append(rb_usascii_str_new(head, headsz),
rb_external_str_new_with_enc(errmsg, strlen(errmsg), oci8_encoding));
}
static VALUE rb_smbdir_read(VALUE self)
{
RB_SMBFILE_DATA_FROM_OBJ(self, data);
RB_SMBFILE_DATA_CLOSED(data);
smbc_readdir_fn fn;
struct smbc_dirent *smbcdent;
fn = smbc_getFunctionReaddir(data->smbcctx);
errno = 0;
smbcdent = (*fn)(data->smbcctx, data->smbcfile);
if (smbcdent == NULL) {
if (errno) {
rb_sys_fail(data->url);
}
return Qnil;
}
VALUE args[4];
args[0] = rb_external_str_new_with_enc(smbcdent->name,
strlen(smbcdent->name), data->enc);
args[1] = INT2NUM(smbcdent->smbc_type);
args[2] = rb_str_new2(data->url);
rb_str_cat2(args[2], "/"); /* FIXME: Unless if the last char is not "/" */
rb_str_cat2(args[2], smbcdent->name); /* FIXME: Must be URL encoding */
args[3] = rb_str_new(smbcdent->comment, smbcdent->commentlen);
VALUE entry_obj = rb_class_new_instance(4, args, rb_cSMBDirEntry);
return entry_obj;
}
static VALUE get_rowid_attr(rowid_arg_t *arg)
{
oci8_base_t *base = arg->base;
ub4 attrtype = arg->attrtype;
char buf[MAX_ROWID_LEN];
ub2 buflen;
sword rv;
/* get a rowid descriptor from OCIHandle */
rv = OCIDescriptorAlloc(oci8_envhp, (dvoid*)&arg->ridp, OCI_DTYPE_ROWID, 0, NULL);
if (rv != OCI_SUCCESS)
oci8_env_raise(oci8_envhp, rv);
rv = OCIAttrGet(base->hp.ptr, base->type, arg->ridp, 0, attrtype, oci8_errhp);
if (rv != OCI_SUCCESS) {
oci8_raise(oci8_errhp, rv, NULL);
}
/* convert the rowid descriptor to a string. */
if (have_OCIRowidToChar) {
/* If OCIRowidToChar is available, use it. */
buflen = MAX_ROWID_LEN;
rv = OCIRowidToChar(arg->ridp, TO_ORATEXT(buf), &buflen, oci8_errhp);
if (rv != OCI_SUCCESS) {
oci8_raise(oci8_errhp, rv, NULL);
}
} else {
/* If OCIRowidToChar is not available, convert it on
* Oracle Server.
*/
oci8_base_t *svc;
oci8_exec_sql_var_t define_var;
oci8_exec_sql_var_t bind_var;
/* search a connection from the handle */
svc = base;
while (svc->type != OCI_HTYPE_SVCCTX) {
svc = svc->parent;
if (svc == NULL) {
rb_raise(rb_eRuntimeError, "No connection is found!!");
}
}
/* :strval */
define_var.valuep = buf;
define_var.value_sz = sizeof(buf);
define_var.dty = SQLT_CHR;
define_var.indp = NULL;
define_var.alenp = &buflen;
/* :rowid */
bind_var.valuep = &arg->ridp;
bind_var.value_sz = sizeof(void *);
bind_var.dty = SQLT_RDD;
bind_var.indp = NULL;
bind_var.alenp = NULL;
/* convert the rowid descriptor to a string value by querying Oracle server. */
oci8_exec_sql((oci8_svcctx_t*)svc, "SELECT :rid FROM dual", 1, &define_var, 1, &bind_var, 1);
if (buflen == 0) {
return Qnil;
}
}
return rb_external_str_new_with_enc(buf, buflen, rb_usascii_encoding());
}
VALUE rxml_new_cstr_len(const char* xstr, const int length, const char* xencoding)
{
#ifdef HAVE_RUBY_ENCODING_H
rb_encoding *rbencoding = rxml_figure_encoding(xencoding);
return rb_external_str_new_with_enc(xstr, length, rbencoding);
#endif
return rb_str_new(xstr, length);
}
VALUE rxml_new_cstr(const char* xstr, const char* xencoding)
{
#ifdef HAVE_RUBY_ENCODING_H
rb_encoding *rbencoding = rxml_figure_encoding(xencoding);
return rb_external_str_new_with_enc(xstr, strlen(xstr), rbencoding);
#endif
return rb_str_new2(xstr);
}
VALUE oci8_get_string_attr(oci8_base_t *base, ub4 attrtype)
{
text *val;
ub4 size;
sword rv;
rv = OCIAttrGet(base->hp.ptr, base->type, &val, &size, attrtype, oci8_errhp);
if (rv != OCI_SUCCESS)
oci8_raise(oci8_errhp, rv, NULL);
return rb_external_str_new_with_enc(TO_CHARPTR(val), size, oci8_encoding);
}
VALUE rxml_str_new2(const char* xstr, const char* xencoding)
{
#ifdef HAVE_RUBY_ENCODING_H
if (xencoding)
{
xmlCharEncoding xmlEncoding = xmlParseCharEncoding(xencoding);
VALUE encoding = rxml_xml_encoding_to_rb_encoding(mXMLEncoding, xmlEncoding);
rb_encoding* xencodingPtr = (rb_encoding*) RDATA(encoding)->data;
return rb_external_str_new_with_enc(xstr, strlen(xstr), xencodingPtr);
}
#endif
return rb_str_new2(xstr);
}
/*
* call-seq:
* attr_get_string(attr_type) -> string
*
* <b>(new in 2.0.4)</b>
*
* Gets the value of an attribute as `oratext *' datatype.
* The return value is converted to Encoding.default_internal or
* tagged with OCI8.encoding when the ruby version is 1.9.
*
* <b>Caution:</b> If the specified attr_type's datatype is not a
* pointer type, it causes a segmentation fault.
*/
static VALUE attr_get_string(VALUE self, VALUE attr_type)
{
oci8_base_t *base = DATA_PTR(self);
union {
char *value;
ub8 dummy; /* padding for incorrect attrtype to protect the stack */
} v;
ub4 size = 0;
v.dummy = MAGIC_NUMBER;
Check_Type(attr_type, T_FIXNUM);
oci_lc(OCIAttrGet(base->hp.ptr, base->type, &v.value, &size, FIX2INT(attr_type), oci8_errhp));
return rb_external_str_new_with_enc(v.value, size, oci8_encoding);
}
static VALUE get_error_msg(dvoid *errhp, ub4 type, const char *default_msg, sb4 *errcode_p)
{
sword rv;
size_t len;
retry:
errbuf[0] = '\0';
rv = OCIErrorGet(errhp, 1, NULL, errcode_p, TO_ORATEXT(errbuf), errbufsiz, type);
/* OCI manual says:
* If type is set to OCI_HTYPE_ERROR, then the return
* code during truncation for OCIErrorGet() is
* OCI_ERROR. The client can then specify a bigger
* buffer and call OCIErrorGet() again.
*
* But as far as I tested on Oracle XE 10.2.0.1, the return
* code is OCI_SUCCESS when the message is truncated.
*/
len = strlen(errbuf);
if (errbufsiz - len <= 7) {
/* The error message may be truncated.
* The magic number 7 means the maximum length of one utf-8
* character plus the length of a nul terminator.
*/
errbufsiz += ERRBUF_EXPAND_LEN;
errbuf = xrealloc(errbuf, errbufsiz);
goto retry;
}
if (rv != OCI_SUCCESS) {
/* No message is found. Use the default message. */
return rb_usascii_str_new_cstr(default_msg);
}
/* truncate trailing CR and LF */
while (len > 0 && (errbuf[len - 1] == '\n' || errbuf[len - 1] == '\r')) {
len--;
}
return rb_external_str_new_with_enc(errbuf, len, oci8_encoding);
}
/* call-seq:
* getlogin -> String
*
* Returns the short user name of the currently logged in user.
* Unfortunately, it is often rather easy to fool ::getlogin.
*
* Avoid ::getlogin for security-related purposes.
*
* If ::getlogin fails, try ::getpwuid.
*
* See the unix manpage for <code>getpwuid(3)</code> for more detail.
*
* e.g.
* Etc.getlogin -> 'guest'
*/
static VALUE
etc_getlogin(VALUE obj)
{
char *login;
#ifdef HAVE_GETLOGIN
login = getlogin();
if (!login) login = getenv("USER");
#else
login = getenv("USER");
#endif
if (login) {
#ifdef _WIN32
rb_encoding *extenc = rb_utf8_encoding();
#else
rb_encoding *extenc = rb_locale_encoding();
#endif
return rb_external_str_new_with_enc(login, strlen(login), extenc);
}
return Qnil;
}
static VALUE oci8_make_exc(dvoid *errhp, sword status, ub4 type, OCIStmt *stmthp, const char *file, int line)
{
VALUE exc;
char errmsg[128];
sb4 errcode = -1;
VALUE msg;
VALUE parse_error_offset = Qnil;
VALUE sql = Qnil;
int rv;
int numarg = 1;
switch (status) {
case OCI_ERROR:
exc = eOCIError;
msg = get_error_msg(errhp, type, "Error", &errcode);
numarg = 4;
break;
case OCI_SUCCESS_WITH_INFO:
exc = eOCISuccessWithInfo;
msg = get_error_msg(errhp, type, "Error", &errcode);
numarg = 4;
break;
case OCI_NO_DATA:
exc = eOCINoData;
msg = get_error_msg(errhp, type, "No Data", &errcode);
numarg = 4;
break;
case OCI_INVALID_HANDLE:
exc = eOCIInvalidHandle;
msg = rb_usascii_str_new_cstr("Invalid Handle");
break;
case OCI_NEED_DATA:
exc = eOCINeedData;
msg = rb_usascii_str_new_cstr("Need Data");
break;
case OCI_STILL_EXECUTING:
exc = eOCIStillExecuting;
msg = rb_usascii_str_new_cstr("Still Executing");
break;
case OCI_CONTINUE:
exc = eOCIContinue;
msg = rb_usascii_str_new_cstr("Continue");
break;
default:
sprintf(errmsg, "Unknown error (%d)", status);
exc = eOCIException;
msg = rb_usascii_str_new_cstr(errmsg);
}
if (stmthp != NULL) {
ub2 offset;
text *text;
ub4 size;
rv = OCIAttrGet(stmthp, OCI_HTYPE_STMT, &offset, 0, OCI_ATTR_PARSE_ERROR_OFFSET, errhp);
if (rv == OCI_SUCCESS) {
parse_error_offset = INT2FIX(offset);
}
rv = OCIAttrGet(stmthp, OCI_HTYPE_STMT, &text, &size, OCI_ATTR_STATEMENT, errhp);
if (rv == OCI_SUCCESS) {
sql = rb_external_str_new_with_enc(TO_CHARPTR(text), size, oci8_encoding);
}
}
exc = rb_funcall(exc, oci8_id_new, numarg, msg, INT2FIX(errcode), sql, parse_error_offset);
return set_backtrace(exc, file, line);
}
VALUE string_spec_rb_external_str_new_with_enc(VALUE self, VALUE str, VALUE len, VALUE encoding) {
return rb_external_str_new_with_enc(RSTRING_PTR(str), FIX2LONG(len), rb_to_encoding(encoding));
}
static VALUE attr_get_common(int argc, VALUE *argv, VALUE self, enum datatype datatype)
{
oci8_base_t *base = DATA_PTR(self);
VALUE attr_type;
VALUE strict;
union {
ub1 ub1val;
ub2 ub2val;
ub4 ub4val;
ub8 ub8val;
sb1 sb1val;
sb2 sb2val;
sb4 sb4val;
sb8 sb8val;
boolean booleanval;
char *charptr;
ub1 *ub1ptr;
} v;
ub4 size = 0;
sword rv;
v.ub8val = MAGIC_NUMBER;
rb_scan_args(argc, argv, "11", &attr_type, &strict);
if (argc == 1) {
strict = Qtrue;
}
Check_Type(attr_type, T_FIXNUM);
rv = OCIAttrGet(base->hp.ptr, base->type, &v, &size, FIX2INT(attr_type), oci8_errhp);
if (!RTEST(strict)) {
if (rv == OCI_ERROR && oci8_get_error_code(oci8_errhp) == 24328) {
/* ignore ORA-24328: illegal attribute value */
return Qnil;
}
}
chker2(rv, base);
switch (datatype) {
OCINumber onum;
static VALUE cOraDate = Qnil;
case DATATYPE_UB1:
return INT2FIX(v.ub1val);
case DATATYPE_UB2:
return INT2FIX(v.ub2val);
case DATATYPE_UB4:
return UINT2NUM(v.ub4val);
case DATATYPE_UB8:
return ULL2NUM(v.ub8val);
case DATATYPE_SB1:
return INT2FIX(v.sb1val);
case DATATYPE_SB2:
return INT2FIX(v.sb2val);
case DATATYPE_SB4:
return INT2NUM(v.sb4val);
case DATATYPE_SB8:
return LL2NUM(v.sb8val);
case DATATYPE_BOOLEAN:
return v.booleanval ? Qtrue : Qfalse;
case DATATYPE_STRING:
if (size == 0 && !RTEST(strict)) {
return Qnil;
}
return rb_external_str_new_with_enc(v.charptr, size, oci8_encoding);
case DATATYPE_BINARY:
return rb_tainted_str_new(v.charptr, size);
case DATATYPE_INTEGER:
if (size > sizeof(onum.OCINumberPart) - 1) {
rb_raise(rb_eRuntimeError, "Too long size %u", size);
}
memset(&onum, 0, sizeof(onum));
onum.OCINumberPart[0] = size;
memcpy(&onum.OCINumberPart[1], v.ub1ptr, size);
return oci8_make_integer(&onum, oci8_errhp);
case DATATYPE_ORADATE:
if (NIL_P(cOraDate))
cOraDate = rb_eval_string("OraDate");
return rb_funcall(cOraDate, oci8_id_new, 6,
INT2FIX((v.ub1ptr[0] - 100) * 100 + (v.ub1ptr[1] - 100)),
INT2FIX(v.ub1ptr[2]),
INT2FIX(v.ub1ptr[3]),
INT2FIX(v.ub1ptr[4] - 1),
INT2FIX(v.ub1ptr[5] - 1),
INT2FIX(v.ub1ptr[6] - 1));
}
return Qnil;
}
/*
* bind_string
*/
static VALUE bind_string_get(oci8_bind_t *obind, void *data, void *null_struct)
{
oci8_vstr_t *vstr = (oci8_vstr_t *)data;
return rb_external_str_new_with_enc(vstr->buf, vstr->size, oci8_encoding);
}