/*
nbytes = MG_NET_SENDTO(socket, variable, host, port)
Sends the raw byte data from the IDL variable on the socket. Returns the
number of bytes sent or -1 for error. Note: no byteswapping is performed.
*/
static IDL_VPTR IDL_CDECL mg_net_sendto(int argc, IDL_VPTR argv[], char *argk) {
IDL_LONG i, iNum, iRet;
struct sockaddr_in sin;
IDL_VPTR vpTmp;
char *pbuffer;
short port;
int host, addr_len;
i = IDL_LongScalar(argv[0]);
if ((i < 0) || (i >= MAX_SOCKETS)) return (IDL_GettmpLong(-1));
if (net_list[i].iState != NET_IO) return (IDL_GettmpLong(-1));
IDL_ENSURE_SIMPLE(argv[1]);
vpTmp = argv[1];
port = (short) IDL_LongScalar(argv[3]);
host = IDL_ULongScalar(argv[2]);
if (vpTmp->type == IDL_TYP_STRING) {
vpTmp = IDL_CvtByte(1, &vpTmp);
}
IDL_VarGetData(vpTmp, &iNum, &pbuffer, 1);
iNum = iNum * IDL_TypeSizeFunc(vpTmp->type);
sin.sin_addr.s_addr = host;
sin.sin_family = AF_INET;
sin.sin_port = htons(port);
addr_len = sizeof(struct sockaddr_in);
iRet = sendto(net_list[i].socket, pbuffer, iNum, 0, (struct sockaddr *) &sin, addr_len);
if (vpTmp != argv[1]) IDL_Deltmp(vpTmp);
return(IDL_GettmpLong(iRet));
}
//
// idlpgr_WriteRegister
//
// Write unsigned integer to specified register
//
void IDL_CDECL idlpgr_WriteRegister(int argc, IDL_VPTR argv[])
{
fc2Error error;
fc2Context context;
unsigned int address, value;
context = (fc2Context) IDL_ULong64Scalar(argv[0]);
address = (unsigned int) IDL_ULongScalar(argv[1]);
value = (unsigned int) IDL_ULongScalar(argv[2]);
error = fc2WriteRegister(context, address, value);
if (error)
IDL_MessageFromBlock(msgs, M_IDLPGR_ERRORCODE, IDL_MSG_LONGJMP,
"Could not write value to specified register",
error);
}
// MYSQL * STDCALL mysql_real_connect(MYSQL *mysql, const char *host,
// const char *user, const char *passwd,
// const char *db, unsigned int port,
// const char *unix_socket,
// unsigned long clientflag);
static IDL_VPTR IDL_mg_mysql_real_connect(int argc, IDL_VPTR *argv) {
MYSQL *mysql = mysql_real_connect((MYSQL *) argv[0]->value.ptrint,
IDL_VarGetString(argv[1]),
IDL_VarGetString(argv[2]),
IDL_VarGetString(argv[3]),
argv[4]->value.str.slen == 0 ? NULL : IDL_VarGetString(argv[4]),
IDL_ULongScalar(argv[5]),
argv[6]->value.str.slen == 0 ? NULL : IDL_VarGetString(argv[6]),
IDL_ULong64Scalar(argv[7]));
return IDL_GettmpMEMINT((IDL_MEMINT) mysql);
}
/*
name = MG_NET_HOST2NAME([host])
Converts the unsigned long host value into an string hostname. If [host]
is not specified, the local hostname is returned.
*/
static IDL_VPTR IDL_CDECL mg_net_host2name(int argc, IDL_VPTR argv[], char *argk) {
struct in_addr addr;
struct hostent *hp;
char host_name[256];
if (argc == 0) {
if (gethostname(host_name, 256) == -1) {
host_name[0] = '\0';
}
return (IDL_StrToSTRING(host_name));
} else {
addr.s_addr = IDL_ULongScalar(argv[0]);
hp = gethostbyaddr((char *)&addr, sizeof(struct in_addr), AF_INET);
if (!hp) return (IDL_StrToSTRING(""));
}
return (IDL_StrToSTRING(hp->h_name));
}
//
// idlpgr_ReadRegister
//
// Read contents of specified register
//
IDL_VPTR IDL_CDECL idlpgr_ReadRegister(int argc, IDL_VPTR argv[])
{
fc2Error error;
fc2Context context;
unsigned int address, value;
context = (fc2Context) IDL_ULong64Scalar(argv[0]);
address = (unsigned int) IDL_ULongScalar(argv[1]);
error = fc2ReadRegister(context, address, &value);
if (error)
IDL_MessageFromBlock(msgs, M_IDLPGR_ERRORCODE, IDL_MSG_LONGJMP,
"Could not read from specified register",
error);
return IDL_GettmpULong((IDL_ULONG) value);
}
// int mysql_options(MYSQL *mysql, enum mysql_option option, const char *arg)
static IDL_VPTR IDL_mg_mysql_options(int argc, IDL_VPTR *argv) {
char *value;
switch (argv[2]->type) {
case IDL_TYP_BYTE:
value = (char *) &argv[2]->value.c;
break;
case IDL_TYP_ULONG:
value = (char *) &argv[2]->value.ul;
break;
case IDL_TYP_STRING:
value = IDL_VarGetString(argv[2]);
break;
}
int status = mysql_options((MYSQL *)argv[0]->value.ptrint,
IDL_ULongScalar(argv[1]),
value);
return IDL_GettmpLong(status);
}
// not part of mysql.h, but needed to access the C fields
// typedef char **MYSQL_ROW;
static IDL_VPTR IDL_mg_mysql_get_blobfield(int argc, IDL_VPTR *argv) {
MYSQL_ROW row = (MYSQL_ROW) argv[0]->value.ptrint;
IDL_ULONG field_index = IDL_ULongScalar(argv[1]);
unsigned long length = IDL_ULong64Scalar(argv[2]);
char *field = row[field_index];
IDL_ARRAY_DIM dims;
IDL_VPTR blob;
char *blob_data;
int i;
dims[0] = length;
blob_data = (char *) IDL_MakeTempArray(IDL_TYP_BYTE,
1,
dims,
IDL_ARR_INI_NOP,
&blob);
for (i = 0; i < length; i++) {
blob_data[i] = field[i];
}
return blob;
}
/*
err = MG_NET_SENDVAR(socket, variable [, host] [, port])
Sends a complete IDL variable to a socket for reading by MG_NET_RECVVAR. The
variable must be one of the basic types, but strings and arrays are sent
with array dimensions and lengths intact.
When sending data from a UDP socket, you must specify the remote host and
port arguments where host is the value returned from the MG_NET_NAME2HOST
function.
Note: This is the easiest way to send a complete variable from one IDL to
another. The receiver will byteswap the data if necessary. One should be
careful not to mix calls to MG_NET_SEND/RECV and MG_NET_SENDVAR/RECVVAR as
the latter send formatted information. You can use the two calls on the same
socket as long as they are paired.
*/
static IDL_VPTR IDL_CDECL mg_net_sendvar(int argc, IDL_VPTR argv[], char *argk) {
IDL_LONG i;
i_var var;
int host, addr_len;
short port;
IDL_LONG iRet;
IDL_VPTR vpTmp;
char *pbuffer;
struct sockaddr_in sin;
i = IDL_LongScalar(argv[0]);
if ((i < 0) || (i >= MAX_SOCKETS)) return (IDL_GettmpLong(-1));
if (net_list[i].iState != NET_IO) return (IDL_GettmpLong(-1));
IDL_ENSURE_SIMPLE(argv[1]);
vpTmp = argv[1];
if (net_list[i].iType == NET_UDP) {
if (argc == 4) {
host = IDL_ULongScalar(argv[2]);
port = (short) IDL_LongScalar(argv[3]);
} else {
IDL_MessageFromBlock(msg_block,
MG_NET_ERROR,
IDL_MSG_RET,
"This UDP socket requires the destination HOST and PORT arguments.");
}
}
var.token = TOKEN;
var.type = vpTmp->type;
if ((var.type == IDL_TYP_STRUCT) ||
(var.type == IDL_TYP_PTR) ||
(var.type == IDL_TYP_OBJREF) ||
(var.type == IDL_TYP_UNDEF)) {
IDL_MessageFromBlock(msg_block,
MG_NET_BADTYPE,
IDL_MSG_LONGJMP,
IDL_TypeNameFunc(var.type));
}
if (vpTmp->type == IDL_TYP_STRING) {
if (vpTmp->flags & IDL_V_ARR) return (IDL_GettmpLong(-1));
pbuffer = IDL_STRING_STR(&(vpTmp->value.str));
var.ndims = 0;
var.len = vpTmp->value.str.slen + 1;
var.nelts = var.len;
} else if (vpTmp->flags & IDL_V_ARR) {
pbuffer = vpTmp->value.arr->data;
var.ndims = vpTmp->value.arr->n_dim;
var.len = vpTmp->value.arr->arr_len;
var.nelts = vpTmp->value.arr->n_elts;
memcpy(var.dims, vpTmp->value.arr->dim, IDL_MAX_ARRAY_DIM * sizeof(IDL_LONG));
} else {
pbuffer = &(vpTmp->value.c);
var.ndims = 0;
var.len = IDL_TypeSizeFunc(var.type);
var.nelts = 1;
}
/* send native, recvvar swaps if needed */
if (net_list[i].iType == NET_UDP) {
sin.sin_addr.s_addr = host;
sin.sin_family = AF_INET;
sin.sin_port = htons(port);
addr_len = sizeof(struct sockaddr_in);
iRet = sendto(net_list[i].socket, (char *) &var, sizeof(i_var), 0,
(struct sockaddr *) &sin, addr_len);
if (iRet == -1) return(IDL_GettmpLong(iRet));
iRet = sendto(net_list[i].socket, pbuffer, var.len, 0,
(struct sockaddr *) &sin, addr_len);
} else {
iRet = send(net_list[i].socket,(char *) &var, sizeof(i_var), 0);
if (iRet == -1) return (IDL_GettmpLong(iRet));
iRet = send(net_list[i].socket, pbuffer, var.len, 0);
}
return(IDL_GettmpLong(1));
}
/*
socket = MG_NET_CONNECT(host, port [, BUFFER=size] [, LOCAL_PORT=lp]
[, /NODELAY] [, /TCP] [, /UDP])
Connect to a TCP socket listener on some specified host and port. The
returned socket can be used for I/O after the server "accepts" the
connection.
The BUFFER keyword can be used to set the socket buffer size. For
high-performance TCP/IP networks (e.g. gigE), higher bandwidth can be
achieved by setting the buffer size to several megabytes. Setting the
NODELAY keyword disables the Nagle algorithm for the socket (appropriate for
applications with large numbers of small packets).
Set the UDP keyword to create a UDP port with the peer address set to the
provided host and port value. Data can then be sent using the MG_NET_SEND
function which is somehwhat more efficient than the MG_NET_SENDTO function.
This is useful if you will be sending data to primarily one host/port.
MG_NET_CONNECT only creates TCP based sockets.
*/
static IDL_VPTR IDL_CDECL mg_net_connect(int argc, IDL_VPTR inargv[], char *argk) {
SOCKET s;
struct sockaddr_in sin;
int addr_len,err;
short port;
int host;
IDL_LONG i;
IDL_VPTR argv[2];
static IDL_LONG iBuffer,iNoDelay,iUDP,iTCP, iLocPort;
static IDL_KW_PAR kw_pars[] = { IDL_KW_FAST_SCAN,
{ "BUFFER", IDL_TYP_LONG, 1, IDL_KW_ZERO, 0, IDL_CHARA(iBuffer) },
{ "LOCAL_PORT", IDL_TYP_LONG, 1, IDL_KW_ZERO, 0, IDL_CHARA(iLocPort) },
{ "NODELAY", IDL_TYP_LONG, 1, IDL_KW_ZERO, 0, IDL_CHARA(iNoDelay) },
{ "TCP", IDL_TYP_LONG, 1, IDL_KW_ZERO, 0, IDL_CHARA(iTCP) },
{ "UDP", IDL_TYP_LONG, 1, IDL_KW_ZERO, 0, IDL_CHARA(iUDP) },
{ NULL }
};
IDL_KWCleanup(IDL_KW_MARK);
IDL_KWGetParams(argc,inargv,argk,kw_pars,argv,1);
host = IDL_ULongScalar(argv[0]);
port = (short) IDL_LongScalar(argv[1]);
IDL_KWCleanup(IDL_KW_CLEAN);
for (i = 0; i < MAX_SOCKETS; i++) {
if (net_list[i].iState == NET_UNUSED) break;
}
if (i == MAX_SOCKETS) return (IDL_GettmpLong(-2));
if (iUDP) {
s = socket(AF_INET,SOCK_DGRAM, 0);
net_list[i].iType = NET_UDP_PEER;
} else {
s = socket(AF_INET, SOCK_STREAM, 0);
if (iBuffer) rebuffer_socket(s, iBuffer);
if (iNoDelay) nodelay_socket(s, 1);
net_list[i].iType = NET_TCP;
}
if (s == -1) return (IDL_GettmpLong(-2));
if (iLocPort) {
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = htonl(INADDR_ANY);
sin.sin_port = htons((short)iLocPort);
err=bind(s,(struct sockaddr *)&sin, sizeof(sin));
if (err == -1) {
CLOSE(s);
return(IDL_GettmpLong(-2));
}
}
sin.sin_addr.s_addr = host;
sin.sin_family = AF_INET;
sin.sin_port = htons(port);
addr_len = sizeof(struct sockaddr_in);
err = connect(s, (struct sockaddr *)&sin, addr_len);
if (err == -1) {
CLOSE(s);
return (IDL_GettmpLong(-1));
}
net_list[i].iState = NET_IO;
net_list[i].socket = s;
return (IDL_GettmpLong(i));
}
// not part of mysql.h, but needed to access the C fields
// typedef char **MYSQL_ROW;
static IDL_VPTR IDL_mg_mysql_get_field(int argc, IDL_VPTR *argv) {
MYSQL_ROW row = (MYSQL_ROW) argv[0]->value.ptrint;
IDL_ULONG field_index = IDL_ULongScalar(argv[1]);
char *field = row[field_index];
return IDL_StrToSTRING(field);
}
