void receiveOblify( struct Oblify *oblify , int *sock )
{
ssize_t n;
socklen_t aLength;
aLength = sizeof(aSocketAddress);
if ((n = recvfrom( *sock , buffer , BUFFERSIZE , 0 ,
(struct sockaddr *)&aSocketAddress , &aLength )) < 0)
perror( "Receive" );
else{
//printSocketAddress( aSocketAddress );
buffer[n] = 0;
if (packetForMe() == 1) {
createOblifyFromMessage( oblify , (int)n );
if (oblify->destinationID == 0 || oblify->destinationID == deviceID) {
// DEBUG print
//printOblify( *oblify , packetNumber++ , "Received" );
unsigned short type = oblify->type;
(type < 20 && type >= 0) ? packethandler[type]( oblify ) : unknownType();
}
}
}
}
/****** cull/db/lJoin() *******************************************************
* NAME
* lJoin() -- Joins two lists together
*
* SYNOPSIS
* lList* lJoin(const char *name, int nm0, const lList *lp0,
* const lCondition *cp0, const lEnumeration *enp0,
* int nm1, const lList *lp1, const lCondition *cp1,
* const lEnumeration *enp1)
*
* FUNCTION
* Returns a new list joining together the lists 'lp0' and 'lp1'
* For the join only these 'lines' described in condition 'cp0'
* and 'cp1' are used.
* The new list gets only these members described in 'enp0' and
* 'enp1'. NULL means every member of this list.
* The list gets 'name' as listname.
*
* INPUTS
* const char *name - name of new list
* int nm0 -
* const lList *lp0 - first list
* const lCondition *cp0 - selects rows of first list
* const lEnumeration *enp0 - selects column of first list
* int nm1 -
* const lList *lp1 - second list
* const lCondition *cp1 - selects rows of second list
* const lEnumeration *enp1 - selects column of seconf list
*
* RESULT
* lList* - Joined list
******************************************************************************/
lList *lJoin(const char *name, int nm0, const lList *lp0,
const lCondition *cp0, const lEnumeration *enp0, int nm1,
const lList *lp1, const lCondition *cp1, const lEnumeration *enp1)
{
lListElem *ep0, *ep1;
lListElem *ep;
lList *dlp = NULL;
lDescr *dp;
int lp0_pos = 0, lp1_pos = 0;
int i, j;
int needed;
DENTER(CULL_LAYER, "lJoin");
if (!lp0 || !lp1 || !name || !enp0 || !enp1) {
LERROR(LENULLARGS);
DEXIT;
return NULL;
}
if (nm1 != NoName) {
if ((lp0_pos = lGetPosInDescr(lGetListDescr(lp0), nm0)) < 0) {
LERROR(LENAMENOT);
DEXIT;
return NULL;
}
if ((lp1_pos = lGetPosInDescr(lGetListDescr(lp1), nm1)) < 0) {
LERROR(LENAMENOT);
DEXIT;
return NULL;
}
if (mt_get_type(lp0->descr[lp0_pos].mt) != mt_get_type(lp1->descr[lp1_pos].mt) ||
mt_get_type(lp0->descr[lp0_pos].mt) == lListT) {
LERROR(LEDIFFDESCR);
DEXIT;
return NULL;
}
}
/* the real join ?! */
if (!(dp = lJoinDescr(lGetListDescr(lp0), lGetListDescr(lp1), enp0, enp1))) {
LERROR(LEJOINDESCR);
DEXIT;
return NULL;
}
if (!(dlp = lCreateList(name, dp))) {
LERROR(LECREATELIST);
sge_free(&dp);
DEXIT;
return NULL;
}
/* free dp it has been copied by lCreateList */
sge_free(&dp);
for (i = 0, ep0 = lp0->first; i < lp0->nelem; i++, ep0 = ep0->next) {
if (!lCompare(ep0, cp0))
continue;
for (j = 0, ep1 = lp1->first; j < lp1->nelem; j++, ep1 = ep1->next) {
if (!lCompare(ep1, cp1))
continue;
if (nm1 != NoName) { /* in this case take it always */
/* This is a comparison of the join fields nm0 , nm1 */
switch (mt_get_type(lp0->descr[lp0_pos].mt)) {
case lIntT:
needed = (ep0->cont[lp0_pos].i == ep1->cont[lp1_pos].i);
break;
case lUlongT:
needed = (ep0->cont[lp0_pos].ul == ep1->cont[lp1_pos].ul);
break;
case lStringT:
needed = !strcmp(ep0->cont[lp0_pos].str, ep1->cont[lp1_pos].str);
break;
case lHostT:
needed = !strcmp(ep0->cont[lp0_pos].str, ep1->cont[lp1_pos].str);
break;
case lLongT:
needed = (ep0->cont[lp0_pos].l == ep1->cont[lp1_pos].l);
break;
case lFloatT:
needed = (ep0->cont[lp0_pos].fl == ep1->cont[lp1_pos].fl);
break;
case lDoubleT:
needed = (ep0->cont[lp0_pos].db == ep1->cont[lp1_pos].db);
break;
case lCharT:
needed = (ep0->cont[lp0_pos].c == ep1->cont[lp1_pos].c);
break;
case lBoolT:
needed = (ep0->cont[lp0_pos].b == ep1->cont[lp1_pos].b);
break;
case lRefT:
needed = (ep0->cont[lp0_pos].ref == ep1->cont[lp1_pos].ref);
break;
default:
unknownType("lJoin");
DEXIT;
return NULL;
}
if (!needed)
continue;
}
if (!(ep = lJoinCopyElem(dlp->descr, ep0, enp0, ep1, enp1))) {
LERROR(LEJOINCOPYELEM);
lFreeList(&dlp);
DEXIT;
return NULL;
}
else {
if (lAppendElem(dlp, ep) == -1) {
LERROR(LEAPPENDELEM);
lFreeList(&dlp);
DEXIT;
return NULL;
}
}
}
}
/* RETURN AN EMPTY LIST OR NULL THAT'S THE QUESTION */
if (lGetNumberOfElem(dlp) == 0) {
lFreeList(&dlp);
}
DEXIT;
return dlp;
}
/****** cull/dump_scan/lUndumpElemFp() ******************************************
* NAME
* lUndumpElemFp() -- Read element from FILE stream
*
* SYNOPSIS
* lListElem* lUndumpElemFp(FILE *fp, const lDescr *dp)
*
* FUNCTION
* Read element from FILE stream
*
* INPUTS
* FILE *fp - file stream
* const lDescr *dp - descriptor
*
* RESULT
* lListElem* - Read element
******************************************************************************/
lListElem *lUndumpElemFp(FILE *fp, const lDescr *dp)
{
lListElem *ep;
int n, i;
int ret = 0;
char *str;
u_long32 dummy;
DENTER(CULL_LAYER, "lUndumpElemFp");
if (!fp) {
LERROR(LEFILENULL);
DEXIT;
return NULL;
}
if (!dp) {
LERROR(LEDESCRNULL);
DEXIT;
return NULL;
}
if (!(ep = lCreateElem(dp))) {
LERROR(LECREATEELEM);
DEXIT;
return NULL;
}
if ((n = lCountDescr(dp)) <= 0) {
LERROR(LECOUNTDESCR);
lFreeElem(&ep);
DEXIT;
return NULL;
}
/* read bra */
if (fGetBra(fp)) {
printf("bra is missing\n");
LERROR(LESYNTAX);
lFreeElem(&ep);
DEXIT;
return NULL;
}
for (i = 0; i < n && ret == 0; i++) {
switch (mt_get_type(dp[i].mt)) {
case lIntT:
ret = fGetInt(fp, &(ep->cont[i].i));
break;
case lUlongT:
ret = fGetUlong(fp, &(ep->cont[i].ul));
break;
case lStringT:
ret = fGetString(fp, &str);
if (ret == 0) {
lSetPosString(ep, i, str);
free(str); /* fGetString strdup's */
}
break;
case lHostT:
ret = fGetHost(fp, &str);
if (ret == 0) {
lSetPosHost(ep, i, str);
free(str); /* fGetHost strdup's */
}
break;
case lFloatT:
ret = fGetFloat(fp, &(ep->cont[i].fl));
break;
case lDoubleT:
ret = fGetDouble(fp, &(ep->cont[i].db));
break;
case lLongT:
ret = fGetLong(fp, &(ep->cont[i].l));
break;
case lCharT:
ret = fGetChar(fp, &(ep->cont[i].c));
break;
case lBoolT:
ret = fGetBool(fp, &(ep->cont[i].b));
break;
case lRefT:
/* we will not undump references! But we have to skip the line! */
ret = fGetUlong(fp, &dummy);
ep->cont[i].ref = NULL;
break;
case lObjectT:
ret = fGetObject(fp, &(ep->cont[i].obj));
break;
case lListT:
ret = fGetList(fp, &(ep->cont[i].glp));
break;
default:
lFreeElem(&ep);
unknownType("lUndumpElemFp");
}
}
/* error handling for loop */
if (ret != 0) {
lFreeElem(&ep);
LERROR(LEFIELDREAD);
DEXIT;
return NULL;
}
/* read ket */
if (fGetKet(fp)) {
lFreeElem(&ep);
printf("ket is missing\n");
LERROR(LESYNTAX);
DEXIT;
return NULL;
}
DEXIT;
return ep;
}
