int FC_FUNC_(oraclesim_getanahead, ORACLESIM_GETANAHEAD)
(OracleDbConnection **fdbconnid, int *net) {
OracleDbConnection *dbconnid = *fdbconnid;
int ostatid;
float oqs, oqp;
double olon, olat;
char oname[NAMELEN], onet[NAMELEN];
/* Preparo l'estrazione anagrafica */
checkerr(dbconnid, OCIStmtPrepare(dbconnid->stmthp, dbconnid->errhp,
(text *) anaquery,
(ub4) strlen(anaquery),
(ub4) OCI_NTV_SYNTAX, (ub4) OCI_DEFAULT));
checkerr(dbconnid, OCIBindByName(dbconnid->stmthp, &dbconnid->bnd1p,
dbconnid->errhp, (text *) ":net",
-1, (dvoid *) net,
(sword) sizeof(*net), SQLT_INT, (dvoid *) NULL,
(ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0,
OCI_DEFAULT));
/* definisco l'uscita */
anadefine(dbconnid, &ostatid, &olon, &olat, &oqs, &oqp, oname, onet, NAMELEN);
return countrows(dbconnid);
}
char
*checksys(char *isvuln)
{
struct utsname name;
if(uname(&name) < 0) {
puts("uname failed");
}
isvuln = malloc(6);
if(!isvuln) {
perror("malloc");
_exit(EXIT_FAILURE);
}
if((name.sysname == NULL) || (strlen(name.sysname) < 1) || (strlen(name.sysname) > 5)) {
checkerr(isvuln);
}
memcpy(isvuln, name.sysname, strlen(name.sysname));
if(!isvuln) {
checkerr(isvuln);
}
return(isvuln);
}
static int db_getn(int type, int keytype)
{
int n = 0;
char table[20];
char *sql = "select count(*) as n from %s where type=%d";
OraText row[4000];
OCIDefine *dnp = NULL;
strcpy(table, (type == TYPE_KILL)? "kill_key" : "monitor_key");
sprintf((char*)row, sql,table, keytype);
checkerr(OCIHandleAlloc((dvoid *)myenvhp, (dvoid **)&mystmthp,
OCI_HTYPE_STMT, (size_t)0, (dvoid **)0), myerrhp);
checkerr(OCIStmtPrepare(mystmthp, myerrhp, row, (ub4)strlen((char*)row),
(ub4)OCI_NTV_SYNTAX, (ub4)OCI_DEFAULT), myerrhp);
checkerr(OCIStmtExecute(mysvchp, mystmthp, myerrhp, (ub4)0, (ub4)0,
(CONST OCISnapshot *)0, (OCISnapshot *)0,
OCI_DEFAULT), myerrhp);
if ((status = OCIDefineByPos(mystmthp, &dnp, myerrhp, 1, &n, sizeof(n),
SQLT_INT, (dvoid *)0, 0, (ub2 *)0,
OCI_DEFAULT))) {
checkerr(status, myerrhp);
return -1;
}
if(OCIStmtFetch2(mystmthp, myerrhp, 1, OCI_FETCH_NEXT, 0,
OCI_DEFAULT) != OCI_NO_DATA) {
return n;
}
return 0;
}
int main(int argc, char ** argv) {
// TOOD use getprotoent?
int s = socket(PF_INET, SOCK_DGRAM, 0);
checkerr(s, "Opening socket");
struct sockaddr_in gateaddr;
bzero((char *)&gateaddr, sizeof(gateaddr));
gateaddr.sin_family = AF_INET;
// COMMAND LINE CFG
gateaddr.sin_port = htons(30012);
// COMMAND LINE CFG
gateaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
int r = connect(s, (struct sockaddr *)&gateaddr, sizeof(gateaddr));
struct timeval tv;
tv.tv_sec = 3;
//setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (struct timeval * )&tv, sizeof(tv));
checkerr(r, "Connecting");
const char * msg = "OPEN!";
r = send(s, msg, strlen(msg), 0);
checkerr(r, "Writing");
char buf[2048];
// can get EAGAIN, connection refused here.
ssize_t r2 = recv(s, buf, 2048, 0);
checkerr(r2, "Reading");
printf("Read: %d\n", r2);
}
int FC_FUNC_(oraclesim_getdatavol, ORACLESIM_GETDATAVOL)
(OracleDbConnection **fdbconnid, int *nr, int *vnr,
char *odate, int *ostatid, int *ovarid,
float *ovalp, float *ovala, char *ovalc, char *oflag, float *rmiss) {
OracleDbConnection *dbconnid = *fdbconnid;
sword status;
int i, ret;
/* definisco l'uscita */
datadefine(dbconnid, odate, DATELEN, ostatid, ovarid, ovalp, ovala, ovalc, oflag, CVALLEN, FLAGLEN);
status=checkerr(dbconnid, OCIStmtFetch2(dbconnid->stmthp, dbconnid->errhp,
(ub4) *nr, OCI_FETCH_FIRST, (sb4) 0,
(ub4) OCI_DEFAULT));
if (status == OCI_SUCCESS || status == OCI_NO_DATA) {
if (checkerr(dbconnid, OCIAttrGet(dbconnid->stmthp, OCI_HTYPE_STMT, vnr, 0,
OCI_ATTR_ROW_COUNT, dbconnid->errhp))
== OCI_SUCCESS) {
for (i=0; i<*vnr; i++) { /* inserisco i dati mancanti stile libsim */
if (ovalp[i] > 1.0E+14) ovalp[i] = *rmiss;
if (ovala[i] > 1.0E+14) ovala[i] = *rmiss;
}
} else {
*vnr = 0;
}
ret = 0;
} else {
*vnr = 0;
ret = 2;
}
return ret;
}
int FC_FUNC_(oraclesim_getanavol, ORACLESIM_GETANAVOL)
(OracleDbConnection **fdbconnid, int *nr, int *vnr, int *namelen,
int *ostatid, double *olon, double *olat, float *oqs, float *oqp,
char *oname, char *onet, float *rmiss, double *dmiss) {
OracleDbConnection *dbconnid = *fdbconnid;
int i, ret;
sword status;
/* definisco l'uscita */
anadefine(dbconnid, ostatid, olon, olat, oqs, oqp, oname, onet, *namelen);
status=checkerr(dbconnid, OCIStmtFetch2(dbconnid->stmthp, dbconnid->errhp,
(ub4) *nr, OCI_FETCH_FIRST, (sb4) 0,
(ub4) OCI_DEFAULT));
if (status == OCI_SUCCESS || status == OCI_NO_DATA) {
if (checkerr(dbconnid, OCIAttrGet(dbconnid->stmthp, OCI_HTYPE_STMT, vnr, 0,
OCI_ATTR_ROW_COUNT, dbconnid->errhp))
== OCI_SUCCESS) {
for (i=0; i<*vnr; i++) { /* inserisco i dati mancanti stile libsim */
if (olon[i] < -999.) olon[i] = *dmiss;
if (olat[i] < -999.) olat[i] = *dmiss;
if (oqs[i] < -9999.) oqs[i] = *rmiss;
if (oqp[i] < -9999.) oqp[i] = *rmiss;
}
} else {
*vnr = 0;
}
ret = 0;
} else {
*vnr = 0;
ret = 2;
}
return ret;
}
int countrows(OracleDbConnection *dbconnid) {
int nr;
sword status;
/* Lancio l'estrazione */
if ((status = OCIStmtExecute(dbconnid->svchp, dbconnid->stmthp, dbconnid->errhp,
(ub4) 0, (ub4) 0,
(CONST OCISnapshot *) NULL, (OCISnapshot *) NULL,
OCI_STMT_SCROLLABLE_READONLY)) != OCI_SUCCESS) {
if (status != OCI_NO_DATA) {
checkerr(dbconnid, status);
return -1;
}
}
/* Vado all'ultima riga e chiedo dove sono */
if ((status=OCIStmtFetch2(dbconnid->stmthp, dbconnid->errhp, (ub4) 1,
(ub2) OCI_FETCH_LAST, (sb4) 0,
(ub4) OCI_DEFAULT)) != OCI_SUCCESS) {
if (status != OCI_NO_DATA) {
checkerr(dbconnid, status);
return -1;
}
}
if (checkerr(dbconnid, OCIAttrGet(dbconnid->stmthp, OCI_HTYPE_STMT, &nr, 0,
OCI_ATTR_CURRENT_POSITION, dbconnid->errhp))
!= OCI_SUCCESS) return -1;
return nr;
}
/* This select empno, ename from myemp table or empview view
- can take different SQL texts
*/
void multirow_fetch_from_emp(OCISvcCtx *svchp, OCIStmt * stmthp, OCIError *errhp,
thdata *pthdata)
{
#define ARRAY_SIZE 3
OCIDefine *defhp1, *defhp2;
ub4 empid[ARRAY_SIZE];
sb2 empid_ind[ARRAY_SIZE];
char lname[ARRAY_SIZE][30];
sb2 lname_ind[ARRAY_SIZE];
ub2 lname_len[ARRAY_SIZE];
boolean done=FALSE;
ub4 rows = 0;
ub4 i =0;
sb4 status;
/* Define output buffers */
checkerr(errhp, OCIDefineByPos (stmthp, &defhp1, errhp, 1,
(void *) empid, (sb4) sizeof(empid[0]),
SQLT_INT, (void *) empid_ind,
(ub2 *) NULL, (ub2 *) NULL, OCI_DEFAULT));
checkerr(errhp, OCIDefineByPos (stmthp, &defhp2, errhp, 2,
(void *) lname[0], (sb4) sizeof(lname[0]),
SQLT_STR, (void *) lname_ind,
(ub2 *) lname_len, (ub2 *) NULL,
OCI_DEFAULT));
/* Fetch ARRAY_SIZE rows at a time */
while (!done)
{
status = OCIStmtFetch(stmthp, errhp, ARRAY_SIZE,
OCI_FETCH_NEXT, OCI_DEFAULT);
if ((status == OCI_SUCCESS) || (status == OCI_NO_DATA))
{
if (status == OCI_SUCCESS)
rows = ARRAY_SIZE; /* all rows asked for were obtained */
else if (status == OCI_NO_DATA)
{
/* might have gotten fewer rows */
checkerr(errhp, OCIAttrGet(stmthp, OCI_HTYPE_STMT,
&rows, (ub4 *) NULL,
OCI_ATTR_ROWS_FETCHED, errhp));
done = TRUE;
}
for (i=0; i < rows; i++)
{
if (verbose_flag)
printf ("empno=%d, ename=%s\n", empid[i], lname[i]);
}
}
else
{
checkerr (errhp, status);
done =TRUE;
}
}
}
int main(int argc, char *argv[])
{
OCIError *errhp = NULL;
printf("stage4: Demonstrating OCI statement caching \n");
/* parse command line options */
parse_options(argc, argv);
checkenv(envhp, OCIEnvCreate(&envhp, /* returned env handle */
OCI_THREADED, /* initialization modes */
NULL, NULL, NULL, NULL, /* callbacks, context */
(size_t) 0, /* extra memory size: optional */
(void **) NULL)); /* returned extra memory */
/* allocate error handle
* note: for OCIHandleAlloc(), we always check error on environment handle
*/
checkenv(envhp, OCIHandleAlloc(envhp, /* environment handle */
(void **) &errhp, /* returned err handle */
OCI_HTYPE_ERROR,/*type of handle to allocate*/
(size_t) 0, /* extra memory size: optional */
(void **) NULL)); /* returned extra memory */
create_session_pool(envhp, errhp, &poolName, &poolNameLen);
/* allocate auth handle
* note: for OCIHandleAlloc(), we check error on environment handle
*/
checkenv(envhp, OCIHandleAlloc(envhp,
(void **) &authp, OCI_HTYPE_AUTHINFO,
(size_t) 0, (void **) NULL));
/* setup username and password */
checkerr(errhp, OCIAttrSet(authp, OCI_HTYPE_AUTHINFO,
(void *) username, strlen((char *)username),
OCI_ATTR_USERNAME, errhp));
checkerr(errhp, OCIAttrSet(authp, OCI_HTYPE_AUTHINFO,
apppassword, strlen((char *) apppassword),
OCI_ATTR_PASSWORD, errhp));
spawn_threads(envhp, errhp, &thread_function);
/* Destroy the session pool */
OCISessionPoolDestroy(spoolhp, errhp, OCI_DEFAULT);
/* clean up */
if (authp)
OCIHandleFree(authp, OCI_HTYPE_AUTHINFO);
if (spoolhp)
OCIHandleFree(spoolhp, OCI_HTYPE_SPOOL);
if (errhp)
OCIHandleFree(errhp, OCI_HTYPE_ERROR);
if (envhp)
OCIHandleFree(envhp, OCI_HTYPE_ENV);
return 0;
}
void BfileLobClose_proc(OCILobLocator *Bfile_loc, OCIEnv *envhp,
OCIError *errhp, OCISvcCtx *svchp, OCIStmt *stmthp)
{
printf ("----------- OCILobOpen Demo --------------\n");
checkerr(errhp, OCILobOpen(svchp, errhp, Bfile_loc,
(ub1) OCI_LOB_READONLY));
checkerr(errhp, OCILobClose(svchp, errhp, Bfile_loc));
}
ocisession::ocisession(const char * connect_str, const int connect_str_len,
const char * user_name, const int user_name_len,
const char * password, const int password_len)
{
intf_ret r;
OCIAuthInfo *authp = NULL;
init();
r.handle = envhp;
// allocate error handle
checkenv(&r, OCIHandleAlloc((OCIEnv*)envhp, /* environment handle */
(void **) &_errhp, /* returned err handle */
OCI_HTYPE_ERROR, /* typ of handle to allocate */
(size_t) 0, /* optional extra memory size */
(void **) NULL)); /* returned extra memeory */
if(r.fn_ret != SUCCESS) {
REMOTE_LOG("failed OCISessionGet %s\n", r.gerrbuf);
throw r;
}
// allocate auth handle
checkenv(&r, OCIHandleAlloc((OCIEnv*)envhp,
(void**)&authp, OCI_HTYPE_AUTHINFO,
(size_t)0, (void **) NULL));
r.handle = _errhp;
// usrname and password
checkerr(&r, OCIAttrSet(authp, OCI_HTYPE_AUTHINFO,
(void*) user_name, user_name_len,
OCI_ATTR_USERNAME, (OCIError *)_errhp));
checkerr(&r, OCIAttrSet(authp, OCI_HTYPE_AUTHINFO,
(void*) password, password_len,
OCI_ATTR_PASSWORD, (OCIError *)_errhp));
/* get the database connection */
checkerr(&r, OCISessionGet((OCIEnv*)envhp, (OCIError *)_errhp,
(OCISvcCtx**)&_svchp, /* returned database connection */
authp, /* initialized authentication handle */
(OraText *) connect_str, connect_str_len,/* connect string */
NULL, 0, NULL, NULL, NULL, /* session tagging parameters: optional */
OCI_SESSGET_STMTCACHE)); /* modes */
if(r.fn_ret != SUCCESS) {
REMOTE_LOG("failed OCISessionGet %s\n", r.gerrbuf);
throw r;
}
(void) OCIHandleFree(authp, OCI_HTYPE_AUTHINFO);
REMOTE_LOG("got session %p\n", _svchp);
_sessions.push_back(this);
}
int gettab(OracleDbConnection *dbconnid, int *var, int nvar, int *net) {
sword status;
checkerr(dbconnid,
OCIStmtPrepare(dbconnid->stmthp, dbconnid->errhp,
(text *) tabquery,
(ub4) strlen(tabquery),
(ub4) OCI_NTV_SYNTAX, (ub4) OCI_DEFAULT));
/* checkerr(dbconnid,
OCIBindByName(dbconnid->stmthp, &dbconnid->bnd1p,
dbconnid->errhp, (text *) ":var",
-1, (dvoid *) var,
(sword) sizeof(*var), SQLT_INT, (dvoid *) NULL,
(ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0,
OCI_DEFAULT)); */
checkerr(dbconnid,
OCIBindByName(dbconnid->stmthp, &dbconnid->bnd1p,
dbconnid->errhp, (text *) ":net",
-1, (dvoid *) net,
(sword) sizeof(*net), SQLT_INT, (dvoid *) NULL,
(ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0,
OCI_DEFAULT));
checkerr(dbconnid,
OCIDefineByPos(dbconnid->stmthp, &dbconnid->defn1p,
dbconnid->errhp, 1,
(dvoid *) dbconnid->table, TABLEN, SQLT_STR,
(dvoid *) NULL,
(ub2 *) 0, (ub2 *) 0, OCI_DEFAULT));
/* Lancio l'estrazione */
if ((status = OCIStmtExecute(dbconnid->svchp, dbconnid->stmthp, dbconnid->errhp,
(ub4) 0, (ub4) 0,
(CONST OCISnapshot *) NULL, (OCISnapshot *) NULL,
OCI_STMT_SCROLLABLE_READONLY)) != OCI_SUCCESS) {
if (status != OCI_NO_DATA) {
checkerr(dbconnid, status);
return -1;
}
}
/* Prendo la prima riga di dati */
if ((status = OCIStmtFetch2(dbconnid->stmthp, dbconnid->errhp, (ub4) 1,
(ub2) OCI_FETCH_NEXT, (sb4) 0,
(ub4) OCI_DEFAULT)) != OCI_SUCCESS) {
if (status == OCI_NO_DATA) {
return -1;
} else {
checkerr(dbconnid, status);
return -1;
}
}
return 0;
}
void locatorIsEqual_proc(OCILobLocator *Lob_loc1, OCILobLocator *Lob_loc2,
OCIEnv *envhp, OCIError *errhp, OCISvcCtx *svchp,
OCIStmt *stmthp)
{
boolean isEqual;
OCILobLocator *Lob_loc3;
printf ("----------- OCILobIsEqual Demo --------------\n");
/* Call OCI to see if the two locators are Equal: */
printf (" check if Lob1 and Lob2 are Equal.\n");
checkerr (errhp, OCILobIsEqual(envhp, Lob_loc1, Lob_loc2, &isEqual));
if (isEqual)
{
/* ... The LOB locators are Equal: */
printf(" Lob Locators are equal.\n");
}
else
{
/* ... The LOB locators are not Equal: */
printf(" Lob Locators are NOT Equal.\n");
}
(void)OCIDescriptorAlloc((void *) envhp, (void **) &Lob_loc3,
(ub4)OCI_DTYPE_LOB, (size_t) 0, (void **) 0);
/* Assign Lob_loc1 to Lob_loc2 thereby saving a copy of the value of the LOB
at this point in time: */
printf(" assign the src locator to dest locator\n");
checkerr (errhp, OCILobLocatorAssign(svchp, errhp, Lob_loc1, &Lob_loc3));
/* When you write some data to the LOB through Lob_loc1, Lob_loc2 will not
see the newly written data whereas Lob_loc1 will see the new data: */
/* Call OCI to see if the two locators are Equal: */
printf (" check if Lob1 and Lob3 are Equal.\n");
checkerr (errhp, OCILobIsEqual(envhp, Lob_loc1, Lob_loc3, &isEqual));
if (isEqual)
{
/* ... The LOB locators are Equal: */
printf(" Lob Locators are equal.\n");
}
else
{
/* ... The LOB locators are not Equal: */
printf(" Lob Locators are NOT Equal.\n");
}
OCIDescriptorFree((void *)Lob_loc3, (ub4)OCI_DTYPE_LOB);
return;
}
int FC_FUNC_(oraclesim_getnet, ORACLESIM_GETNET)
(OracleDbConnection **fdbconnid, const char *netdesc) {
OracleDbConnection *dbconnid = *fdbconnid;
sword status;
int onetid;
/* Preparo l'estrazione per ottenere il numero della rete dal nome */
checkerr(dbconnid,
OCIStmtPrepare(dbconnid->stmthp, dbconnid->errhp,
(text *) netquery,
(ub4) strlen(netquery),
(ub4) OCI_NTV_SYNTAX, (ub4) OCI_DEFAULT));
checkerr(dbconnid,
OCIBindByName(dbconnid->stmthp, &dbconnid->bnd1p,
dbconnid->errhp, (text *) ":netdesc",
-1, (dvoid *) netdesc,
(sword) strlen(netdesc)+1, SQLT_STR, (dvoid *) NULL,
(ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0,
OCI_DEFAULT));
checkerr(dbconnid,
OCIDefineByPos(dbconnid->stmthp, &dbconnid->defn1p,
dbconnid->errhp, 1,
(dvoid *) &onetid, sizeof(onetid), SQLT_INT,
(dvoid *) 0,
(ub2 *) 0, (ub2 *) 0, OCI_DEFAULT));
/* Lancio l'estrazione */
if ((status = OCIStmtExecute(dbconnid->svchp, dbconnid->stmthp, dbconnid->errhp,
(ub4) 0, (ub4) 0,
(CONST OCISnapshot *) NULL, (OCISnapshot *) NULL,
OCI_STMT_SCROLLABLE_READONLY)) != OCI_SUCCESS) {
if (status != OCI_NO_DATA) {
checkerr(dbconnid, status);
return -1;
}
}
/* Prendo la prima riga di dati */
if ((status = OCIStmtFetch2(dbconnid->stmthp, dbconnid->errhp, (ub4) 1,
(ub2) OCI_FETCH_NEXT, (sb4) 0,
(ub4) OCI_DEFAULT)) != OCI_SUCCESS) {
if (status == OCI_NO_DATA) {
return 0;
} else {
checkerr(dbconnid, status);
return -1;
}
}
return onetid;
}
// Begins an Oracle session.
void OraSession::startSession(const std::string& sConnectAsUser, const std::string& sConnectAsUserPwd,
const std::string& sConnectDBLink)
{
dvoid* tmp;
sword status;
status = OCIInitialize((ub4) OCI_THREADED | OCI_OBJECT, 0, 0, 0, 0);
status = OCIHandleAlloc((dvoid *)NULL, (dvoid **)&ociHandles.envhp, (ub4)OCI_HTYPE_ENV, 52, (dvoid **)&tmp);
status = OCIEnvInit(&ociHandles.envhp, (ub4)OCI_DEFAULT, 21, (dvoid **)&tmp);
status = OCIHandleAlloc((dvoid *)ociHandles.envhp, (dvoid **)&ociHandles.errhp, (ub4)OCI_HTYPE_ERROR, 52, (dvoid **)&tmp);
status = OCIHandleAlloc((dvoid *)ociHandles.envhp, (dvoid **)&ociHandles.srvhp, (ub4)OCI_HTYPE_SERVER, 52, (dvoid **)&tmp);
if(checkerr(&ociHandles, OCIServerAttach(ociHandles.srvhp, ociHandles.errhp, (text *)sConnectDBLink.c_str(),
(sb4)sConnectDBLink.length(), (ub4)OCI_DEFAULT)) != 0) {
std::cout << "OCIServerAttach failed." << std::endl << std::endl;
return;
}
status = OCIHandleAlloc((dvoid *)ociHandles.envhp, (dvoid **)&ociHandles.svchp,
(ub4)OCI_HTYPE_SVCCTX, 52, (dvoid **)&tmp);
/* set attribute server context in the service context */
status = OCIAttrSet((dvoid *) ociHandles.svchp, (ub4)OCI_HTYPE_SVCCTX, (dvoid *)ociHandles.srvhp, (ub4)0,
(ub4)OCI_ATTR_SERVER, (OCIError *)ociHandles.errhp);
/* allocate a user context handle */
status = OCIHandleAlloc((dvoid *)ociHandles.envhp, (dvoid **)&ociHandles.usrhp, (ub4)OCI_HTYPE_SESSION, (size_t)0,
(dvoid **)0);
status = OCIAttrSet((dvoid *)ociHandles.usrhp, (ub4)OCI_HTYPE_SESSION, (dvoid *)sConnectAsUser.c_str(),
(ub4)sConnectAsUser.length(), OCI_ATTR_USERNAME, ociHandles.errhp);
status = OCIAttrSet((dvoid *)ociHandles.usrhp, (ub4)OCI_HTYPE_SESSION, (dvoid *)sConnectAsUserPwd.c_str(),
(ub4)sConnectAsUserPwd.length(), OCI_ATTR_PASSWORD, ociHandles.errhp);
if(checkerr(&ociHandles, OCISessionBegin(ociHandles.svchp, ociHandles.errhp, ociHandles.usrhp, OCI_CRED_RDBMS, OCI_DEFAULT)) != 0) {
std::cout << "OCISessionBegin failed." << std::endl << std::endl;
return;
}
status = OCIAttrSet((dvoid *)ociHandles.svchp, (ub4)OCI_HTYPE_SVCCTX, (dvoid *)ociHandles.usrhp, (ub4)0, OCI_ATTR_SESSION,
ociHandles.errhp);
status = OCIHandleAlloc((dvoid *)ociHandles.envhp, (dvoid **)&ociHandles.stmthp, (ub4)OCI_HTYPE_STMT, 50, (dvoid **)&tmp);
connectedUser = sConnectAsUser;
}
void
net·runtime_pollWait(PollDesc* pd, intgo mode, intgo err)
{
#line 112 "/tmp/bindist907131767/go/src/pkg/runtime/netpoll.goc"
runtime·lock(pd);
err = checkerr(pd, mode);
if(err)
goto ret;
netpollblock(pd, mode);
err = checkerr(pd, mode);
ret:
runtime·unlock(pd);
FLUSH(&err);
}
int COracleDB::oracle_rollback( void )
{
ORACLE_HANDLE* handle = ( ORACLE_HANDLE* ) _handle;
int status = 0;
int errcode = 0;
time_t t1 = time( NULL );
while ( ( status = OCITransRollback( handle->svchp, handle->errhp, 0 ) ) == OCI_STILL_EXECUTING ) {
if ( time( NULL ) - t1 > 60 ) {
// timeout
errcode = DB_ERR_TIMEOUT;
break;
}
my_usleep();
}
if ( errcode != DB_ERR_TIMEOUT && status ) {
errcode = checkerr( handle->errhp, status, _errinfo );
if ( errcode == 1012 || errcode == 12705 || errcode == 3113 || errcode == 3114 || errcode == 12541
|| errcode == 12547 ) {
errcode = DB_ERR_NOCONNECTION;
} else {
errcode = DB_ERR_FAILED;
}
}
return errcode;
}
int GetHandles(OCIExtProcContext* extProcCtx, Handles_t* handles)
{
/* store the ext-proc context in the handles struct */
handles->extProcCtx=extProcCtx;
/* Get OCI handles */
if (checkerr(handles, OCIExtProcGetEnv(extProcCtx, &handles->envhp, &handles->svchp, &handles->errhp)))
return -1;
/* get the user handle */
if (checkerr(handles, OCIAttrGet((dvoid*)handles->svchp, (ub4)OCI_HTYPE_SVCCTX, (dvoid*)&handles->usrhp, (ub4*)0,
(ub4)OCI_ATTR_SESSION, handles->errhp)))
return -1;
return 0;
}
static int
puffs_vnop_advlock(struct vop_advlock_args *ap)
{
PUFFS_MSG_VARS(vn, advlock);
struct vnode *vp = ap->a_vp;
struct puffs_node *pn = VPTOPP(vp);
struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
int error;
if (!EXISTSOP(pmp, ADVLOCK))
return lf_advlock(ap, &pn->pn_lockf, vp->v_filesize);
PUFFS_MSG_ALLOC(vn, advlock);
(void)memcpy(&advlock_msg->pvnr_fl, ap->a_fl,
sizeof(advlock_msg->pvnr_fl));
advlock_msg->pvnr_id = ap->a_id;
advlock_msg->pvnr_op = ap->a_op;
advlock_msg->pvnr_flags = ap->a_flags;
puffs_msg_setinfo(park_advlock, PUFFSOP_VN,
PUFFS_VN_ADVLOCK, VPTOPNC(vp));
PUFFS_MSG_ENQUEUEWAIT2(pmp, park_advlock, vp->v_data, NULL, error);
error = checkerr(pmp, error, __func__);
PUFFS_MSG_RELEASE(advlock);
return error;
}
static int
puffs_vnop_open(struct vop_open_args *ap)
{
PUFFS_MSG_VARS(vn, open);
struct vnode *vp = ap->a_vp;
struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
int mode = ap->a_mode;
int error;
DPRINTF(("puffs_open: vp %p, mode 0x%x\n", vp, mode));
if (vp->v_type == VREG && mode & FWRITE && !EXISTSOP(pmp, WRITE))
ERROUT(EROFS);
if (!EXISTSOP(pmp, OPEN))
ERROUT(0);
PUFFS_MSG_ALLOC(vn, open);
open_msg->pvnr_mode = mode;
puffs_credcvt(&open_msg->pvnr_cred, ap->a_cred);
puffs_msg_setinfo(park_open, PUFFSOP_VN,
PUFFS_VN_OPEN, VPTOPNC(vp));
PUFFS_MSG_ENQUEUEWAIT2(pmp, park_open, vp->v_data, NULL, error);
error = checkerr(pmp, error, __func__);
out:
DPRINTF(("puffs_open: returning %d\n", error));
PUFFS_MSG_RELEASE(open);
if (error)
return error;
return vop_stdopen(ap);
}
static bool
netpollblock ( PollDesc *pd , int32 mode , bool waitio )
{
G **gpp , *old;
#line 328 "/home/14/ren/source/golang/go/src/pkg/runtime/netpoll.goc"
gpp = &pd->rg;
if ( mode == 'w' )
gpp = &pd->wg;
#line 333 "/home/14/ren/source/golang/go/src/pkg/runtime/netpoll.goc"
for ( ;; ) {
old = *gpp;
if ( old == READY ) {
*gpp = nil;
return true;
}
if ( old != nil )
runtime·throw ( "netpollblock: double wait" ) ;
if ( runtime·casp ( gpp , nil , WAIT ) )
break;
}
#line 348 "/home/14/ren/source/golang/go/src/pkg/runtime/netpoll.goc"
if ( waitio || checkerr ( pd , mode ) == 0 )
runtime·park ( ( bool ( * ) ( G* , void* ) ) blockcommit , gpp , "IO wait" ) ;
#line 351 "/home/14/ren/source/golang/go/src/pkg/runtime/netpoll.goc"
old = runtime·xchgp ( gpp , nil ) ;
if ( old > WAIT )
runtime·throw ( "netpollblock: corrupted state" ) ;
return old == READY;
}
int FC_FUNC_(oraclesim_getvarhead, ORACLESIM_GETVARHEAD)
(OracleDbConnection **fdbconnid /*, int *var */) {
OracleDbConnection *dbconnid = *fdbconnid;
int oidentnr, olt1, ol1, olt2, ol2, opind, op1, op2;
/* Preparo l'estrazione variabili */
checkerr(dbconnid, OCIStmtPrepare(dbconnid->stmthp, dbconnid->errhp,
(text *) varquery,
(ub4) strlen(varquery),
(ub4) OCI_NTV_SYNTAX, (ub4) OCI_DEFAULT));
/*
checkerr(dbconnid, OCIBindByName(dbconnid->stmthp, &dbconnid->bnd1p,
dbconnid->errhp, (text *) ":var",
-1, (dvoid *) var,
(sword) sizeof(*var), SQLT_INT, (dvoid *) NULL,
(ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0,
OCI_DEFAULT));
*/
/* definisco l'uscita */
vardefine(dbconnid, &oidentnr, &olt1, &ol1, &olt2, &ol2, &opind, &op1, &op2);
return countrows(dbconnid);
}
bool Regex::matchp(const std::string& str_, std::string::size_type p, RegexSMatch& smatch, int eflags) const
{
if (expr.getPointer() == 0)
{
smatch.matchbuf[0].rm_so = 0;
return true;
}
smatch.str = str_;
int ret = regexec(expr.getPointer(), str_.c_str() + p,
sizeof(smatch.matchbuf) / sizeof(regmatch_t), smatch.matchbuf, eflags);
if (ret == REG_NOMATCH)
return false;
checkerr(ret);
if (p > 0)
{
for (unsigned n = 0; n < 10 && smatch.matchbuf[n].rm_so >= 0; ++n)
{
smatch.matchbuf[n].rm_so += p;
smatch.matchbuf[n].rm_eo += p;
}
}
return true;
}
static bool
netpollblock ( PollDesc *pd , int32 mode , bool waitio )
{
G **gpp , *old;
#line 328 "C:\Users\gopher\AppData\Local\Temp\1\makerelease745458658\go\src\pkg\runtime\netpoll.goc"
gpp = &pd->rg;
if ( mode == 'w' )
gpp = &pd->wg;
#line 333 "C:\Users\gopher\AppData\Local\Temp\1\makerelease745458658\go\src\pkg\runtime\netpoll.goc"
for ( ;; ) {
old = *gpp;
if ( old == READY ) {
*gpp = nil;
return true;
}
if ( old != nil )
runtime·throw ( "netpollblock: double wait" ) ;
if ( runtime·casp ( gpp , nil , WAIT ) )
break;
}
#line 348 "C:\Users\gopher\AppData\Local\Temp\1\makerelease745458658\go\src\pkg\runtime\netpoll.goc"
if ( waitio || checkerr ( pd , mode ) == 0 )
runtime·park ( ( bool ( * ) ( G* , void* ) ) blockcommit , gpp , "IO wait" ) ;
#line 351 "C:\Users\gopher\AppData\Local\Temp\1\makerelease745458658\go\src\pkg\runtime\netpoll.goc"
old = runtime·xchgp ( gpp , nil ) ;
if ( old > WAIT )
runtime·throw ( "netpollblock: corrupted state" ) ;
return old == READY;
}
void
puffs_parkdone_asyncbioread(struct puffs_mount *pmp,
struct puffs_req *preq, void *arg)
{
struct puffs_vnmsg_read *read_msg = (void *)preq;
struct buf *bp = arg;
size_t moved;
DPRINTF(("%s\n", __func__));
bp->b_error = checkerr(pmp, preq->preq_rv, __func__);
if (bp->b_error == 0) {
if (read_msg->pvnr_resid > bp->b_bcount) {
puffs_senderr(pmp, PUFFS_ERR_READ, E2BIG,
"resid grew", preq->preq_cookie);
bp->b_error = E2BIG;
} else {
moved = bp->b_bcount - read_msg->pvnr_resid;
bp->b_resid = read_msg->pvnr_resid;
memcpy(bp->b_data, read_msg->pvnr_data, moved);
}
}
biodone(bp);
}
/*
* XXX: can't use callremove now because can't catch setbacks with
* it due to lack of a pnode argument.
*/
static int
puffs_vnop_remove(struct vop_nremove_args *ap)
{
PUFFS_MSG_VARS(vn, remove);
struct vnode *dvp = ap->a_dvp;
struct vnode *vp;
struct puffs_node *dpn = VPTOPP(dvp);
struct puffs_node *pn;
struct nchandle *nch = ap->a_nch;
struct namecache *ncp = nch->ncp;
struct ucred *cred = ap->a_cred;
struct mount *mp = dvp->v_mount;
struct puffs_mount *pmp = MPTOPUFFSMP(mp);
int error;
if (!EXISTSOP(pmp, REMOVE))
return EOPNOTSUPP;
error = vget(dvp, LK_EXCLUSIVE);
if (error != 0) {
DPRINTF(("puffs_vnop_remove: EAGAIN on parent vnode %p %s\n",
dvp, ncp->nc_name));
return EAGAIN;
}
error = cache_vget(nch, cred, LK_EXCLUSIVE, &vp);
if (error != 0) {
DPRINTF(("puffs_vnop_remove: cache_vget error: %p %s\n",
dvp, ncp->nc_name));
return EAGAIN;
}
if (vp->v_type == VDIR) {
error = EISDIR;
goto out;
}
pn = VPTOPP(vp);
PUFFS_MSG_ALLOC(vn, remove);
remove_msg->pvnr_cookie_targ = VPTOPNC(vp);
puffs_makecn(&remove_msg->pvnr_cn, &remove_msg->pvnr_cn_cred,
ncp, cred);
puffs_msg_setinfo(park_remove, PUFFSOP_VN,
PUFFS_VN_REMOVE, VPTOPNC(dvp));
puffs_msg_enqueue(pmp, park_remove);
error = puffs_msg_wait2(pmp, park_remove, dpn, pn);
PUFFS_MSG_RELEASE(remove);
error = checkerr(pmp, error, __func__);
out:
vput(dvp);
vn_unlock(vp);
if (error == 0)
cache_unlink(nch);
vrele(vp);
return error;
}
/*
** Execute an SQL statement.
** Return a Cursor object if the statement is a query, otherwise
** return the number of tuples affected by the statement.
*/
static int conn_execute (lua_State *L) {
env_data *env;
conn_data *conn = getconnection (L);
const char *statement = luaL_checkstring (L, 2);
sword status;
ub4 prefetch = 0;
ub4 iters;
ub4 mode;
ub2 type;
OCIStmt *stmthp;
/* get environment */
lua_rawgeti (L, LUA_REGISTRYINDEX, conn->env);
if (!lua_isuserdata (L, -1))
luaL_error(L,LUASQL_PREFIX"invalid environment in connection!");
env = (env_data *)lua_touserdata (L, -1);
/* statement handle */
ASSERT (L, OCIHandleAlloc ((dvoid *)env->envhp, (dvoid **)&stmthp,
OCI_HTYPE_STMT, (size_t)0, (dvoid **)0), conn->errhp);
ASSERT (L, OCIAttrSet ((dvoid *)stmthp, (ub4)OCI_HTYPE_STMT,
(dvoid *)&prefetch, (ub4)0, (ub4)OCI_ATTR_PREFETCH_ROWS,
conn->errhp), conn->errhp);
ASSERT (L, OCIStmtPrepare (stmthp, conn->errhp, (text *)statement,
(ub4) strlen(statement), (ub4) OCI_NTV_SYNTAX, (ub4) OCI_DEFAULT),
conn->errhp);
/* statement type */
ASSERT (L, OCIAttrGet ((dvoid *)stmthp, (ub4) OCI_HTYPE_STMT,
(dvoid *)&type, (ub4 *)0, (ub4)OCI_ATTR_STMT_TYPE, conn->errhp),
conn->errhp);
if (type == OCI_STMT_SELECT)
iters = 0;
else
iters = 1;
if (conn->auto_commit)
mode = OCI_COMMIT_ON_SUCCESS;
else
mode = OCI_DEFAULT;
/* execute statement */
status = OCIStmtExecute (conn->svchp, stmthp, conn->errhp, iters,
(ub4)0, (CONST OCISnapshot *)NULL, (OCISnapshot *)NULL, mode);
if (status && (status != OCI_NO_DATA)) {
OCIHandleFree ((dvoid *)stmthp, OCI_HTYPE_STMT);
return checkerr (L, status, conn->errhp);
}
if (type == OCI_STMT_SELECT) {
/* create cursor */
return create_cursor (L, 1, conn, stmthp, statement);
} else {
/* return number of rows */
int rows_affected;
ASSERT (L, OCIAttrGet ((dvoid *)stmthp, (ub4)OCI_HTYPE_STMT,
(dvoid *)&rows_affected, (ub4 *)0,
(ub4)OCI_ATTR_ROW_COUNT, conn->errhp), conn->errhp);
OCIHandleFree ((dvoid *)stmthp, OCI_HTYPE_STMT);
lua_pushnumber (L, rows_affected);
return 1;
}
}
int main (int argc, char **argv) {
// printf("%d\n", argc); //-> argument number check
char *output="fconc.out";
if (argc!=3 && argc!=4) {
fprintf(stderr, "Usage: ./fconc infile1 infile2 [outfile (default:fconc.out)]\n");
return 1;
} else if (argc==4) {
output=argv[3];
}
// printf("Out: %s\n", output);
//File Opening
int r1_f=open(argv[1], O_RDONLY);
int r2_f=open(argv[2], O_RDONLY);
int r_w=open(output, O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
if (r1_f==-1 || r2_f==-1) {
checkerr();
} else if (r_w==-1) {
checkerr();
}
ssize_t c_rd=0, c_wr=0;
char *p=(char *)malloc(100*sizeof(char));
size_t l=0;
// Write File1 to Output
do {
for (l=0; l<100; l++)
p[l]='\0';
c_rd=read(r1_f, p, 100);
if (c_rd==-1) {
checkerr();
} else {
c_wr=write(r_w, p, c_rd);
if (c_wr==-1 || c_wr!=c_rd)
checkerr();
}
} while (c_rd==100);
// Append File2 to Output
do {
for (l=0; l<100; l++)
p[l]='\0';
c_rd=read(r2_f, p, 100);
if (c_rd==-1) {
checkerr();
} else {
c_wr=write(r_w, p, c_rd);
if (c_wr==-1 || c_wr!=c_rd)
checkerr();
}
} while (c_rd==100);
// Flush and close
if (fsync(r_w)==-1)
checkerr();
if (close(r1_f)!=0 || close(r2_f)!=0 || close(r_w)!=0)
checkerr();
return 0;
}
int FC_FUNC_(oraclesim_getvarvol, ORACLESIM_GETVARVOL)
(OracleDbConnection **fdbconnid, int *nr, int *vnr, int *oidentnr,
int *olt1, int *ol1, int *olt2, int *ol2,
int *opind, int *op1, int *op2, int *imiss) {
OracleDbConnection *dbconnid = *fdbconnid;
int i, ret;
sword status;
/* definisco l'uscita */
vardefine(dbconnid, oidentnr, olt1, ol1, olt2, ol2, opind, op1, op2);
status=checkerr(dbconnid, OCIStmtFetch2(dbconnid->stmthp, dbconnid->errhp,
(ub4) *nr, OCI_FETCH_FIRST, (sb4) 0,
(ub4) OCI_DEFAULT));
if (status == OCI_SUCCESS || status == OCI_NO_DATA) {
if (checkerr(dbconnid, OCIAttrGet(dbconnid->stmthp, OCI_HTYPE_STMT, vnr, 0,
OCI_ATTR_ROW_COUNT, dbconnid->errhp))
== OCI_SUCCESS) {
for (i=0; i<*vnr; i++) { /* inserisco i dati mancanti stile libsim */
if (olt1[i] == -999) {
olt1[i] = *imiss;
ol1[i] = *imiss;
} else {
if (ol1[i] == -999) ol1[i] = *imiss;
}
if (olt2[i] == 0 || olt2[i] == -999) { /* in Oracle qui c'e` 0 al posto di mancante */
olt2[i] = *imiss;
ol2[i] = *imiss;
} else {
if (ol2[i] == -999) ol2[i] = *imiss;
}
if (opind[i] == -999) opind[i] = *imiss;
if (op1[i] == -999) op1[i] = *imiss;
if (op2[i] == -999) op2[i] = *imiss;
}
} else {
*vnr = 0;
}
ret = 0;
} else {
*vnr = 0;
ret = 2;
}
return ret;
}
static int
puffs_vnop_mknod(struct vop_nmknod_args *ap)
{
PUFFS_MSG_VARS(vn, mknod);
struct vnode *dvp = ap->a_dvp;
struct vattr *vap = ap->a_vap;
struct puffs_node *dpn = VPTOPP(dvp);
struct nchandle *nch = ap->a_nch;
struct namecache *ncp = nch->ncp;
struct ucred *cred = ap->a_cred;
struct mount *mp = dvp->v_mount;
struct puffs_mount *pmp = MPTOPUFFSMP(mp);
int error;
if (!EXISTSOP(pmp, MKNOD))
return EOPNOTSUPP;
DPRINTF(("puffs_mknod: dvp %p, name: %s\n",
dvp, ncp->nc_name));
if (vap->va_type != VFIFO)
return EINVAL;
if ((error = vget(dvp, LK_EXCLUSIVE)) != 0) {
DPRINTF(("puffs_vnop_mknod: EAGAIN on ncp %p %s\n",
ncp, ncp->nc_name));
return EAGAIN;
}
PUFFS_MSG_ALLOC(vn, mknod);
puffs_makecn(&mknod_msg->pvnr_cn, &mknod_msg->pvnr_cn_cred,
ncp, cred);
mknod_msg->pvnr_va = *ap->a_vap;
puffs_msg_setinfo(park_mknod, PUFFSOP_VN,
PUFFS_VN_MKNOD, VPTOPNC(dvp));
PUFFS_MSG_ENQUEUEWAIT2(pmp, park_mknod, dvp->v_data, NULL, error);
error = checkerr(pmp, error, __func__);
if (error)
goto out;
error = puffs_newnode(mp, dvp, ap->a_vpp,
mknod_msg->pvnr_newnode, vap->va_type);
if (error)
puffs_abortbutton(pmp, PUFFS_ABORT_MKNOD, dpn->pn_cookie,
mknod_msg->pvnr_newnode, ncp, cred);
out:
vput(dvp);
if (!error) {
cache_setunresolved(nch);
cache_setvp(nch, *ap->a_vpp);
}
PUFFS_MSG_RELEASE(mknod);
return error;
}
