/*
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));
}
/*
nbytes = MG_NET_SEND(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.
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.
*/
static IDL_VPTR IDL_CDECL mg_net_send(int argc, IDL_VPTR argv[], char *argk) {
IDL_LONG i, iNum, iRet;
IDL_VPTR vpTmp;
char *pbuffer;
i = IDL_LongScalar(argv[0]);
if ((i < 0) || (i >= MAX_SOCKETS)) return(IDL_GettmpLong(-1));
if ((net_list[i].iState != NET_IO) || (net_list[i].iType != NET_UDP_PEER))
return(IDL_GettmpLong(-1));
IDL_ENSURE_SIMPLE(argv[1]);
vpTmp = argv[1];
if (vpTmp->type == IDL_TYP_STRING) {
vpTmp = IDL_CvtByte(1, &vpTmp);
}
IDL_VarGetData(vpTmp, &iNum, &pbuffer, 1);
iNum = iNum * IDL_TypeSizeFunc(vpTmp->type);
iRet = send(net_list[i].socket, pbuffer, iNum, 0);
if (vpTmp != argv[1]) IDL_Deltmp(vpTmp);
return(IDL_GettmpLong(iRet));
}
// Convert the input IDL_VPTR of IDL_STRINGs to a vector<string> all uppercase
int IDLStruct::IDL_STRING2StringVecUpper(
IDL_VPTR svptr, vector<string>& tagnames)
{
int status=0;
IDL_MEMINT num=0;
IDL_STRING* ptr;
// Checking here, but better to check outside of this in case of memory
// issues
IDL_ENSURE_SIMPLE(svptr);
if (svptr->type != IDL_TYP_STRING)
{
IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO,
"IDL_STRING2StringVecUpper: Input must be of type IDL_STRING");
return(status);
}
IDL_VarGetData(svptr, &num, (char **) &ptr, IDL_TRUE);
tagnames.resize(num);
for (IDL_MEMINT i=0; i<num; i++)
{
string name=ptr[i].s;
// Make upper case
std::transform(name.begin(), name.end(),
name.begin(), (int(*)(int)) toupper);
tagnames[i] = name;
}
status=1;
return(status);
}
// Convert the input numerical variable to a vector<IDL_MEMINT>
int IDLStruct::IDL_VAR2IDL_MEMINTVec(
IDL_VPTR vptr, vector<IDL_MEMINT>& memintvec)
{
int status=0;
// Checking here, but better to check outside of this in case of memory
// issues
IDL_ENSURE_SIMPLE(vptr);
int converted = 0;
if (vptr->type != IDL_TYP_MEMINT)
converted = 1;
// Will return same variable if it is already type IDL_MEMINT
// We have to explicitly release this mem; but at least IDL
// will warn us if we forget
IDL_VPTR vptr_use = IDL_CvtMEMINT(1, &vptr);
// The true will ensure simple, which we have already done
IDL_MEMINT num;
IDL_MEMINT* ptr;
IDL_VarGetData(vptr_use, &num, (char **) &ptr, IDL_TRUE);
memintvec.clear();
if (num > 0)
{
memintvec.resize(num);
for (IDL_MEMINT i=0; i<num; i++)
{
memintvec[i] = ptr[i];
}
}
if (converted)
IDL_Deltmp(vptr_use);
status=1;
return(status);
}
IDL_VPTR rdObjmask(int argc, IDL_VPTR *argv, char *argk) {
/* the desired atlas image. */
ATLAS_IMAGE *ai;
/* The fits file */
FITS *fits;
char *atlasFileName; // The input file name
IDL_VPTR idlistVptr; // optional idlist input keyword
IDL_MEMINT* idlist;
IDL_MEMINT nid=0;
int idiscopy=0;
IDL_MEMINT nrows=0; // actual number of rows in file
IDL_MEMINT i=0, j=0;
IDL_VPTR result; // The result and temporary copies
char* resptr;
char* rowptr;
char* elptr;
IDL_LONG elval;
int elsize;
// Structure definition
void* sdef;
// offsets structure
offsetstruct os;
// First make sure IDL_LONG is 4-byte int
elsize=sizeof(IDL_LONG);
if (elsize != 4)
{
IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_LONGJMP, "sizeof(IDL_LONG) must be 4");
}
/* Get the keywords */
(void) IDL_KWProcessByOffset(argc, argv, argk, kw_pars,
(IDL_VPTR *) 0, 1, &kw);
/* Check arguments */
if (nParams(argc) < 1)
{
IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO,
"Syntax: struct = rdObjmask(atlasFile, idlist=, status=)");
setStatus(FAILURE);
return(IDL_GettmpInt(-1));
}
/* get file name and open fits file */
atlasFileName = getFileNameVal(argv[0]);
if((fits = open_fits_table(atlasFileName, 1)) == NULL) {
/* Memory is cleaned up in open_fits_table() */
setStatus(FAILURE);
return(IDL_GettmpInt(-1));
}
nrows = fits->naxis2;
// See if idlist was sent, else generate a list of all
if (kw.idlist_there)
{
/* make sure it is a MEMINT. Copy if needed */
idlistVptr = getAsMEMINT(argv[1], &idiscopy);
IDL_VarGetData(idlistVptr, &nid, (char **) &idlist, IDL_TRUE);
}
else
{
idiscopy=1;
nid=nrows;
idlist = (IDL_MEMINT *) calloc(nrows, sizeof(IDL_MEMINT));
for (i=1;i<=nrows;i++)
idlist[i-1] = i;
}
/* structure definition and create output */
sdef = IDL_MakeStruct(0, stags);
resptr = IDL_MakeTempStructVector(sdef, nid, &result, IDL_TRUE);
os = GetOffsets(sdef);
/* Copy in the info */
for (i=0;i<nid;i++)
{
// Point to the appropriate row in output data
rowptr = (char *) result->value.s.arr->data + i*( result->value.arr->elt_len );
// Copy id. Do it here since if the object has no atlas image
// it wouldn't be copied
elval = (IDL_LONG) idlist[i];
elptr = rowptr + os.id;
memcpy(elptr, &elval, elsize);
// Read the atlas image
ai = read_atlas_image(fits, (int) idlist[i]);
// In what follows, copy -1 if the ai is invalid
if (ai != NULL)
{
// Copy run
elval = (IDL_LONG) ai->run;
elptr = rowptr + os.run;
memcpy(elptr, &elval, elsize);
// Copy rerun
elval = (IDL_LONG) ai->rerun;
elptr = rowptr + os.rerun;
memcpy(elptr, &elval, elsize);
// Copy camcol
elval = (IDL_LONG) ai->camCol;
elptr = rowptr + os.camcol;
memcpy(elptr, &elval, elsize);
// Copy field
elval = (IDL_LONG) ai->field;
elptr = rowptr + os.field;
memcpy(elptr, &elval, elsize);
// Copy id
//elval = (IDL_LONG) ai->id;
//elptr = rowptr + os.id;
//memcpy(elptr, &elval, elsize);
// Copy parent
elval = (IDL_LONG) ai->parent;
elptr = rowptr + os.parent;
memcpy(elptr, &elval, elsize);
// copy row0
elptr = rowptr + os.row0;
for (j=0;j<5;j++)
{
if (ai->id > 0)
elval = (IDL_LONG) (ai->master_mask->rmin + ai->drow[j]);
else
elval=-1;
memcpy(elptr, &elval, elsize);
elptr+=elsize;
}
// copy col0
elptr = rowptr + os.col0;
for (j=0;j<5;j++)
{
if (ai->id > 0)
elval = (IDL_LONG) (ai->master_mask->cmin + ai->dcol[j]);
else
elval=-1;
memcpy(elptr, &elval, elsize);
elptr+=elsize;
}
// copy rowmax
elptr = rowptr + os.rowmax;
for (j=0;j<5;j++)
{
if (ai->id > 0)
elval = (IDL_LONG) (ai->master_mask->rmax + ai->drow[j]);
else
elval=-1;
memcpy(elptr, &elval, elsize);
elptr+=elsize;
}
// copy colmax
elptr = rowptr + os.colmax;
for (j=0;j<5;j++)
{
if (ai->id > 0)
elval = (IDL_LONG) (ai->master_mask->cmax + ai->dcol[j]);
else
elval=-1;
memcpy(elptr, &elval, elsize);
elptr+=elsize;
}
// copy drow
elptr = rowptr + os.drow;
for (j=0;j<5;j++)
{
if (ai->id > 0)
elval = (IDL_LONG) (ai->drow[j]);
else
elval = -1;
memcpy(elptr, &elval, elsize);
elptr+=elsize;
}
// copy dcol
elptr = rowptr + os.dcol;
for (j=0;j<5;j++)
{
if (ai->id > 0)
elval = (IDL_LONG) (ai->dcol[j]);
else
elval = -1;
memcpy(elptr, &elval, elsize);
elptr+=elsize;
}
phAtlasImageDel(ai,1);
}
}
/* clean up */
phFitsDel(fits);
if (kw.idlist_there & idiscopy)
IDL_Deltmp(idlistVptr);
else
free(idlist);
/* Clean up the keyword info */
IDL_KW_FREE;
setStatus(SUCCESS);
//return(IDL_GettmpInt(-1));
return(result);
}
/*
out = MG_NET_SELECT(sockets[], timeout)
Checks to see if there is data waiting to be read or a connection has been
requested for a list of sockets. The return value is -1 on error, scalar 0
if no sockets are ready or returns a list of the sockets which are ready.
The routine waits the number of seconds specified by the timeout argument
for sockets to become ready. A timeout value of 0 results in a poll of the
sockets.
*/
static IDL_VPTR IDL_CDECL mg_net_select(int argc, IDL_VPTR argv[], char *argk) {
struct timeval timeval;
fd_set rfds;
IDL_LONG i, j;
IDL_LONG n, num;
float fWait;
IDL_LONG *piSocks,iNum;
IDL_VPTR vpSocks;
vpSocks = IDL_CvtLng(1, &(argv[0]));
IDL_VarGetData(vpSocks, &iNum, (char **) &piSocks, 1);
fWait = (float) IDL_DoubleScalar(argv[1]);
num = -1;
FD_ZERO(&rfds);
for (j = 0; j < iNum; j++) {
i = piSocks[j];
if ((i < 0) || (i >= MAX_SOCKETS)) {
if (vpSocks != argv[0]) IDL_Deltmp(vpSocks);
return (IDL_GettmpLong(-1));
}
if (net_list[i].iState != NET_UNUSED) {
FD_SET(net_list[i].socket, &rfds);
if (net_list[i].socket > (SOCKET) num) num = net_list[i].socket;
}
}
while (fWait >= 0.0) {
if (fWait >= 2.0) {
timeval.tv_sec = 2;
timeval.tv_usec = 0;
} else {
timeval.tv_sec = (long) fWait;
fWait = fWait - timeval.tv_sec;
timeval.tv_usec = (long) (fWait * 1000000);
}
n = select(num + 1, &rfds, NULL, NULL, &timeval);
if (n == -1) fWait = -1.0;
if (n > 0) fWait = -1.0;
fWait -= 2.0;
if (IDL_BailOut(IDL_FALSE)) {
n = -1;
fWait = -1.0;
}
}
if (n > 0) {
IDL_LONG *pOut;
IDL_VPTR vpTmp;
pOut = (IDL_LONG *) IDL_MakeTempVector(IDL_TYP_LONG,
n, IDL_ARR_INI_NOP, &vpTmp);
for (j = 0; j < iNum; j++) {
i = piSocks[j];
if (net_list[i].iState != NET_UNUSED) {
if (FD_ISSET(net_list[i].socket, &rfds)){
*pOut++ = i;
}
}
}
if (vpSocks != argv[0]) IDL_Deltmp(vpSocks);
return (vpTmp);
}
if (vpSocks != argv[0]) IDL_Deltmp(vpSocks);
return (IDL_GettmpLong(n));
}
void crehds( int argc, IDL_VPTR argv[] ) {
/*
** Declare variables
*/
char *hdsname; /* The name of the HDS container file to create */
char *strucname; /* The name of the top-level structure */
IDL_VPTR var;
int ndims;
hdsdim dims[DAT__MXDIM];
int status; /* Starlink status */
HDSLoc* toploc = NULL; /* Locator to top object */
int numtags; /* Number of tags = 0 if not a structure */
char hdstype[DAT__SZTYP+1]; /* corresponding HDS type */
int fstat; /* Final status (before emsEload) */
char param[EMS__SZPAR+1]; /* Error message parameter name */
int parlen; /* Length of error message parameter name */
char opstr[EMS__SZMSG+1]; /* Error message */
int oplen; /* Length of error message */
char **taglist; /* Pointer to taglist */
char *data; /* Pointer to data */
IDL_LONG nvals; /* Number of values in var */
int elt_len; /* Length of element of structure */
IDL_STRING *IDL_tags;
hdsdim IDL_ntags;
char defname[12]="IDL2HDS_OUT";
/* Start Error context */
status = SAI__OK;
emsMark();
/* Check that the correct number of arguments were passed in */
if ( ( argc == 2 ) | (argc == 3 ) ) {
var = argv[0];
if ( argv[1]->flags & IDL_V_ARR ) {
IDL_tags = (IDL_STRING *)argv[1]->value.arr->data;
IDL_ntags = (hdsdim)argv[1]->value.arr->n_elts;
} else {
IDL_tags = &argv[1]->value.str;
IDL_ntags = 1;
}
taglist = getstringarray( 1, &IDL_ntags, IDL_tags );
if ( argc == 3 )
hdsname = argv[2]->value.str.s;
else
hdsname = defname;
strucname = hdsname;
IDL_VarGetData( var, &nvals, &data, 0 );
getobjectdetails( var, data, taglist,
hdstype, &numtags, &ndims, dims, &elt_len, &status );
hdsNew( hdsname, strucname, hdstype, ndims, dims, &toploc, &status );
if ( numtags ) {
/* is a structure - invoke the structure handler */
hdsstructwrite(
toploc, data, taglist, numtags, ndims, dims, var, &status );
retstringarray( taglist );
} else {
hdsprimwrite( toploc, hdstype, ndims, dims, data, &status );
}
datAnnul( &toploc, &status );
} else {
status = SAI__ERROR;
emsRep( " ", "crehds: Incorrect number of arguments", &status );
}
/* Report any error messages */
/* Adding Starlink-style !! and ! prefix */
if ( status != SAI__OK ) {
fstat = status;
while ( status != SAI__OK ) {
emsEload(
param, &parlen, opstr, &oplen, &status );
if ( status != SAI__OK )
IDL_Message( IDL_M_NAMED_GENERIC, IDL_MSG_INFO, opstr );
}
}
emsRlse();
/* That's it, return to the calling routine */
return;
}
