Example #1
0
static void GetApplication(MessageHandler *handler, NETFILE *fp,
                           ProcessNode *node) {
  int i;
  ConvFuncs *conv;

  conv = handler->serialize;

  LBS_EmitStart(iobuff);
  RecvLargeString(fp, iobuff);
  ON_IO_ERROR(fp, badio);

  ConvSetRecName(handler->conv, node->mcprec->name);
  conv->UnPackValue(handler->conv, LBS_Body(iobuff), node->mcprec->value);

  if (node->linkrec != NULL) {
    ConvSetRecName(handler->conv, node->linkrec->name);
    conv->UnPackValue(handler->conv, LBS_Body(iobuff), node->linkrec->value);
  }
  if (node->sparec != NULL) {
    ConvSetRecName(handler->conv, node->sparec->name);
    conv->UnPackValue(handler->conv, LBS_Body(iobuff), node->sparec->value);
  }
  for (i = 0; i < node->cWindow; i++) {
    if (node->scrrec[i] != NULL) {
      ConvSetRecName(handler->conv, node->scrrec[i]->name);
      conv->UnPackValue(handler->conv, LBS_Body(iobuff),
                        node->scrrec[i]->value);
    }
  }
  DumpNode(node);
badio:
  return;
}
Example #2
0
static	ValueStruct	*
_DBCOMMIT(
	DBG_Struct	*dbg,
	DBCOMM_CTRL	*ctrl)
{
	int			rc;
	char		*p
	,			*q;
	LargeByteString	*lbs;

ENTER_FUNC;
	CheckDB_Redirect(dbg);
	lbs = (LargeByteString *)dbg->process[PROCESS_UPDATE].conn;
	rc = 0;
	if (LBS_Size(lbs) > 0){
		LBS_EmitEnd(lbs);
		RewindLBS(lbs);
		p = (char *)LBS_Body(lbs);
		while	(  ( q = strchr(p,0xFF) )  !=  NULL  ) {
			*q = 0;
			rc += DoShell(p);
			p = q + 1;
		}
		rc += DoShell(p);
		LBS_String(dbg->last_query,p);
		LBS_Clear(lbs);
	}
	CommitDB_Redirect(dbg);
	if		(  ctrl  !=  NULL  ) {
		ctrl->rc = rc;
	}
LEAVE_FUNC;
	return	(NULL);
}
Example #3
0
extern void RecvLBS(NETFILE *fp, LargeByteString *lbs) {
  size_t size;

  size = RecvLength(fp);
  LBS_ReserveSize(lbs, size, FALSE);
  if (size > 0) {
    Recv(fp, LBS_Body(lbs), size);
  }
}
Example #4
0
static	void
SetFileEntry(
	GtkWidget			*widget,
	WidgetData	*wdata,
	_FileEntry			*data)
{
static GHashTable		*connectlist = NULL;

	GtkPandaFileEntry 	*fentry;
	GtkWidget			*subWidget;
	WidgetData			*subdata;
	char				*longname;
	char				*folder;

ENTER_FUNC;

	SetCommon(widget,wdata);
	fentry = GTK_PANDA_FILE_ENTRY(widget);
	g_return_if_fail(data->binary != NULL);
	longname = (char *)glade_get_widget_long_name(widget);

	if (connectlist == NULL) {
		connectlist = NewNameHash();
	}
    if (g_hash_table_lookup(connectlist, longname) == NULL) {
		g_hash_table_insert(connectlist, longname, longname);
		g_signal_connect_after(G_OBJECT(widget), "done_action", 
			G_CALLBACK(SavePreviousFolder), NULL);
	}

	folder = GetWidgetCache(longname);
	if (folder == NULL) {
		folder = "";
	}
	gtk_panda_file_entry_set_folder(fentry, folder);

	if (LBS_Size(data->binary) > 0) {
		//download
		gtk_panda_file_entry_set_mode(fentry, 
			GTK_FILE_CHOOSER_ACTION_SAVE);
		gtk_panda_file_entry_set_data(fentry,
			LBS_Size(data->binary), LBS_Body(data->binary));
		//set subwidget
		subdata = GetWidgetData(data->subname);
		subWidget = GetWidgetByLongName(data->subname);
		if (subdata != NULL || subWidget != NULL) {
			SetEntry(subWidget, subdata,(_Entry *)subdata->attrs);
		}
		g_signal_emit_by_name(G_OBJECT(widget), "browse_clicked", NULL);
	} else {
		//upload
		gtk_panda_file_entry_set_mode(GTK_PANDA_FILE_ENTRY(widget), 
			GTK_FILE_CHOOSER_ACTION_OPEN);
	}
LEAVE_FUNC;
}
Example #5
0
static	void
SetPandaPreview(
	GtkWidget	*widget,
	WidgetData	*wdata,
	_PREVIEW	*data)
{
ENTER_FUNC;
	SetCommon(widget,wdata);
	gtk_panda_pdf_set(GTK_PANDA_PDF(widget), 
		LBS_Size(data->binary), LBS_Body(data->binary));
LEAVE_FUNC;
}
Example #6
0
static PacketClass SYSDB_RequestCommon(NETFILE *fp, PacketClass pc,
                                       ValueStruct *val) {
  PacketClass rc;
  LargeByteString *buf;
  rc = SESSION_CONTROL_NG;
  buf = NewLBS();
  LBS_ReserveSize(buf, NativeSizeValue(NULL, val), FALSE);
  NativePackValue(NULL, LBS_Body(buf), val);
  SendPacketClass(fp, SYSDATA_SYSDB);
  ON_IO_ERROR(fp, badio);
  SendPacketClass(fp, pc);
  ON_IO_ERROR(fp, badio);
  SendLBS(fp, buf);
  ON_IO_ERROR(fp, badio);
  rc = RecvPacketClass(fp);
  RecvLBS(fp, buf);
  NativeUnPackValue(NULL, LBS_Body(buf), val);
badio:
  FreeLBS(buf);
  return rc;
}
Example #7
0
static	void
GL_SendLBS(
	NETFILE	*fp,
	LargeByteString	*lbs)
{
	GL_SendLength(fp,LBS_Size(lbs));
	if		(  LBS_Size(lbs)  >  0  ) {
		Send(fp,LBS_Body(lbs),LBS_Size(lbs));
		if		(  !CheckNetFile(fp)  ) {
			GL_Error();
		}
	}
}
Example #8
0
static void SetDBAudit(DBG_Struct *dbg) {
  ValueStruct *audit;
  LargeByteString *lbs;

  if (dbg->auditlog > 0) {
    if (ThisEnv->auditrec->value != NULL) {
      audit = ThisEnv->auditrec->value;
      SetValueInteger(GetItemLongName(audit, "ticket_id"), dbg->ticket_id);
      lbs = dbg->last_query;
      if ((lbs != NULL) && (LBS_Size(lbs) > 0)) {
        SetValueString(GetItemLongName(audit, "exec_query"), LBS_Body(lbs),
                       dbg->coding);
      }
    }
  }
}
Example #9
0
static LargeByteString	*
NewLinkData(void)
{
	LargeByteString *linkdata;
	size_t size;

	if (ThisEnv->linkrec != NULL) {
		linkdata = NewLBS();
		size = NativeSizeValue(NULL,ThisEnv->linkrec->value);
		LBS_ReserveSize(linkdata,size,FALSE);
		NativePackValue(NULL,LBS_Body(linkdata),ThisEnv->linkrec->value);
	} else {
		linkdata = NULL;
	}
	return linkdata;
}
Example #10
0
PacketClass SYSDB_GetDataAll(NETFILE *fp, int *size, ValueStruct *vals) {
  PacketClass rc;
  LargeByteString *buf;
  rc = SESSION_CONTROL_NG;
  buf = NewLBS();
  SendPacketClass(fp, SYSDATA_SYSDB);
  ON_IO_ERROR(fp, badio);
  SendPacketClass(fp, SYSDB_GET_DATA_ALL);
  ON_IO_ERROR(fp, badio);
  rc = RecvPacketClass(fp);
  *size = RecvInt(fp);
  RecvLBS(fp, buf);
  NativeUnPackValue(NULL, LBS_Body(buf), vals);
badio:
  FreeLBS(buf);
  return rc;
}
Example #11
0
static void
SetPixmap(
	GtkWidget			*widget,
	WidgetData	*wdata,
	_Pixmap				*data)
{
ENTER_FUNC;
	SetCommon(widget,wdata);
	if ( LBS_Size(data->binary) <= 0) {
		gtk_widget_hide(widget); 
	} else {
		gtk_widget_show(widget); 
		gtk_panda_pixmap_set_image(GTK_PANDA_PIXMAP(widget), 
			(gchar*)LBS_Body(data->binary),(gsize)LBS_Size(data->binary));
	}
LEAVE_FUNC;
}
Example #12
0
static	void
GL_RecvLBS(
	NETFILE	*fp,
	LargeByteString	*lbs)
{
	size_t	size;
ENTER_FUNC;
	size = GL_RecvLength(fp);
	LBS_ReserveSize(lbs,size,FALSE);
	if		(  size  >  0  ) {
		Recv(fp,LBS_Body(lbs),size);
		if		(  !CheckNetFile(fp)  ) {
			GL_Error();
		}
	} else {
		dbgmsg("Recv LBS 0 size.");
	}
LEAVE_FUNC;
}
Example #13
0
static	SessionData	*
InitAPISession(
	char *user,
	char *ldname,
	char *wname,
	char *host)
{
	SessionData		*data;
	LD_Node			*ld;
	RecordStruct	*rec;
	size_t			size;
	uuid_t			u;

ENTER_FUNC;
	data = NewSessionData();
	data->type = SESSION_TYPE_API;
	uuid_generate(u);
	uuid_unparse(u,data->hdr->uuid);
	strcpy(data->hdr->window,wname);
	strcpy(data->hdr->user,user);
	strcpy(data->host,host);
	data->fInProcess = TRUE;
	if ((ld = g_hash_table_lookup(APS_Hash, ldname)) != NULL) {
		data->ld = ld;
		data->linkdata = NULL;
		data->cWindow = ld->info->cWindow;
		data->scrdata = NULL;
		data->hdr->puttype = SCREEN_NULL;
		rec = GetWindow(wname);
		size = NativeSizeValue(NULL,rec->value);
		LBS_ReserveSize(data->apidata->rec, size,FALSE);
		NativePackValue(NULL,LBS_Body(data->apidata->rec),rec->value);
	} else {
		Warning("[%s] session fail LD [%s] not found.",data->hdr->uuid,ldname);
		data = NULL;
	}
LEAVE_FUNC;
	return	(data);
}
Example #14
0
extern	PacketDataType
RecvStringData(
	NETFILE	*fp,
	char	*str,
	size_t	size)
{
	PacketDataType	type;

ENTER_FUNC;
	type = GL_RecvDataType(fp);
	switch	(type) {
	  case	GL_TYPE_INT:
		dbgmsg("int");
		sprintf(str,"%d",GL_RecvInt(fp));
		break;
	  case	GL_TYPE_CHAR:
	  case	GL_TYPE_VARCHAR:
	  case	GL_TYPE_DBCODE:
	  case	GL_TYPE_TEXT:
		GL_RecvString(fp, size, str);
		break;
	  case	GL_TYPE_BINARY:
	  case	GL_TYPE_BYTE:
	  case	GL_TYPE_OBJECT:
		dbgmsg("LBS");
		GL_RecvLBS(fp,LargeBuff);
		if		(  LBS_Size(LargeBuff)  >  0  ) {
			memcpy(str,LBS_Body(LargeBuff),LBS_Size(LargeBuff));
			str[LBS_Size(LargeBuff)] = 0;
		} else {
			*str = 0;
		}
		break;
	}
LEAVE_FUNC;
	return type;
}
Example #15
0
extern	void
SendStringData(
	NETFILE			*fp,
	PacketDataType	type,
	char			*str)
{
ENTER_FUNC;
	GL_SendDataType(fp,type);
	switch	(type) {
	  case	GL_TYPE_CHAR:
	  case	GL_TYPE_VARCHAR:
	  case	GL_TYPE_DBCODE:
	  case	GL_TYPE_TEXT:
		GL_SendString(fp,(char *)str);
		break;
	  case	GL_TYPE_BINARY:
	  case	GL_TYPE_BYTE:
	  case	GL_TYPE_OBJECT:
		LBS_ReserveSize(LargeBuff,strlen(str)+1,FALSE);
		strcpy(LBS_Body(LargeBuff),str);
		GL_SendLBS(fp,LargeBuff);
		break;
	  case	GL_TYPE_INT:
		GL_SendInt(fp,atoi(str));
		break;
	  case	GL_TYPE_FLOAT:
		GL_SendFloat(fp,atof(str));
		break;
	  case	GL_TYPE_BOOL:
		GL_SendBool(fp,(( *str == 'T' ) ? TRUE: FALSE ));
		break;
	  default:
		break;
	}
LEAVE_FUNC;
}
Example #16
0
extern void SendLBS(NETFILE *fp, LargeByteString *lbs) {
  SendLength(fp, LBS_Size(lbs));
  if (LBS_Size(lbs) > 0) {
    Send(fp, LBS_Body(lbs), LBS_Size(lbs));
  }
}
Example #17
0
static void PutApplication(MessageHandler *handler, NETFILE *fp,
                           ProcessNode *node) {
  int i;
  size_t size;
  ConvFuncs *conv;

  DumpNode(node);
  conv = handler->serialize;

  ConvSetRecName(handler->conv, node->mcprec->name);
  size = conv->SizeValue(handler->conv, node->mcprec->value);
  LBS_EmitStart(iobuff);
  LBS_ReserveSize(iobuff, size, FALSE);
  conv->PackValue(handler->conv, LBS_Body(iobuff), node->mcprec->value);
  LBS_EmitEnd(iobuff);
  SendLargeString(fp, iobuff);
  ON_IO_ERROR(fp, badio);
  Send(fp, conv->fsep, strlen(conv->fsep));
  ON_IO_ERROR(fp, badio);

  if (node->linkrec != NULL) {
    ConvSetRecName(handler->conv, node->linkrec->name);
    size = conv->SizeValue(handler->conv, node->linkrec->value);
    LBS_EmitStart(iobuff);
    LBS_ReserveSize(iobuff, size, FALSE);
    conv->PackValue(handler->conv, LBS_Body(iobuff), node->linkrec->value);
    LBS_EmitEnd(iobuff);
    SendLargeString(fp, iobuff);
    ON_IO_ERROR(fp, badio);
    Send(fp, conv->fsep, strlen(conv->fsep));
    ON_IO_ERROR(fp, badio);
  }

  if (node->sparec != NULL) {
    ConvSetRecName(handler->conv, node->sparec->name);
    size = conv->SizeValue(handler->conv, node->sparec->value);
    LBS_EmitStart(iobuff);
    LBS_ReserveSize(iobuff, size, FALSE);
    conv->PackValue(handler->conv, LBS_Body(iobuff), node->sparec->value);
    LBS_EmitEnd(iobuff);
    SendLargeString(fp, iobuff);
    ON_IO_ERROR(fp, badio);
  }

  for (i = 0; i < node->cWindow; i++) {
    LBS_EmitStart(iobuff);
    if (node->scrrec[i] != NULL) {
      ConvSetRecName(handler->conv, node->scrrec[i]->name);
      size = conv->SizeValue(handler->conv, node->scrrec[i]->value);
      if (size > 0) {
        Send(fp, conv->fsep, strlen(conv->fsep));
        ON_IO_ERROR(fp, badio);
      }
      LBS_ReserveSize(iobuff, size, FALSE);
      conv->PackValue(handler->conv, LBS_Body(iobuff), node->scrrec[i]->value);
    }
    LBS_EmitEnd(iobuff);
    SendLargeString(fp, iobuff);
    ON_IO_ERROR(fp, badio);
  }
  Send(fp, conv->bsep, strlen(conv->bsep));
  ON_IO_ERROR(fp, badio);
badio:
  return;
}
Example #18
0
static void ExecuteDB_Server(MessageHandler *handler) {
  RecordStruct *rec;
  ValueStruct *value, *ret;
  PathStruct *path;
  DB_Operation *op;
  size_t size;
  int rno, pno, ono;
  DBCOMM_CTRL ctrl;
  char *rname, *pname, *func;
  ConvFuncs *conv;

  InitializeCTRL(&ctrl);
  conv = handler->serialize;
  while (TRUE) {
    dbgmsg("read");
    LBS_EmitStart(dbbuff);
    RecvLargeString(fpDBR, dbbuff);
    ON_IO_ERROR(fpDBR, badio);
    ConvSetRecName(handler->conv, recDBCTRL->name);
    InitializeValue(recDBCTRL->value);
    conv->UnPackValue(handler->conv, LBS_Body(dbbuff), recDBCTRL->value);
    rname = ValueStringPointer(GetItemLongName(recDBCTRL->value, "rname"));
    strncpy(ctrl.rname, rname, SIZE_NAME);
    value = NULL;
    ret = NULL;
    if ((rname != NULL) &&
        ((rno = (int)(long)g_hash_table_lookup(DB_Table, rname)) != 0)) {
      ctrl.rno = rno - 1;
      rec = ThisDB[ctrl.rno];
      value = rec->value;
      pname = ValueStringPointer(GetItemLongName(recDBCTRL->value, "pname"));
      strncpy(ctrl.pname, pname, SIZE_NAME);
      if ((pno = (int)(long)g_hash_table_lookup(rec->opt.db->paths, pname)) !=
          0) {
        ctrl.pno = pno - 1;
        path = rec->opt.db->path[pno - 1];
        value = (path->args != NULL) ? path->args : value;
      } else {
        ctrl.pno = 0;
        path = NULL;
      }
    } else {
      rec = NULL;
      path = NULL;
    }
    func = ValueStringPointer(GetItemLongName(recDBCTRL->value, "func"));
    if (*func != 0) {
      if (path == NULL) {
        Error("path is NULL");
      } else if ((ono = (int)(long)g_hash_table_lookup(path->opHash, func)) != 0) {
        op = path->ops[ono - 1];
        value = (op->args != NULL) ? op->args : value;
      }
      if (rec != NULL) {
        ConvSetRecName(handler->conv, rec->name);
      } else {
        Error("rec is NULL");
      }
      InitializeValue(value);
      conv->UnPackValue(handler->conv, LBS_Body(dbbuff), value);
      strncpy(ctrl.func, func, SIZE_FUNC);
      ret = ExecDB_Process(&ctrl, rec, value);
    } else {
      ctrl.rc = 0;
    }
    dbgmsg("write");
    SetValueInteger(GetItemLongName(recDBCTRL->value, "rc"), ctrl.rc);
    ConvSetRecName(handler->conv, recDBCTRL->name);
    LBS_EmitStart(dbbuff);
    size = conv->SizeValue(handler->conv, recDBCTRL->value);
    LBS_ReserveSize(dbbuff, size, FALSE);
    conv->PackValue(handler->conv, LBS_Body(dbbuff), recDBCTRL->value);
    LBS_EmitEnd(dbbuff);
    SendLargeString(fpDBW, dbbuff);
    ON_IO_ERROR(fpDBW, badio);
    if (ret != NULL) {
      Send(fpDBW, conv->fsep, strlen(conv->fsep));
      ON_IO_ERROR(fpDBW, badio);
      LBS_EmitStart(dbbuff);
      if (rec != NULL) {
        ConvSetRecName(handler->conv, rec->name);
      }
      size = conv->SizeValue(handler->conv, ret);
      LBS_ReserveSize(dbbuff, size, FALSE);
      conv->PackValue(handler->conv, LBS_Body(dbbuff), ret);
      LBS_EmitEnd(dbbuff);
      SendLargeString(fpDBW, dbbuff);
      ON_IO_ERROR(fpDBW, badio);
      FreeValueStruct(ret);
    }
    Send(fpDBW, conv->bsep, strlen(conv->bsep));
    ON_IO_ERROR(fpDBW, badio);
  }
badio:
  return;
}