static int open_host(char *hostname, int port) {
int net;
struct hostent *host;
struct sockaddr_in sa_in;
bzero((char*)&sa_in,sizeof(sa_in));
if (port){
sa_in.sin_port= htons((u_short)port);
}else{
return(DPS_NET_ERROR);
}
if ((sa_in.sin_addr.s_addr=inet_addr(hostname)) != INADDR_NONE){
sa_in.sin_family=AF_INET;
}else{
host=gethostbyname(hostname);
if (host){
sa_in.sin_family = (sa_family_t)host->h_addrtype;
dps_memcpy(&sa_in.sin_addr, host->h_addr, (size_t)host->h_length);
}else{
return(DPS_NET_CANT_RESOLVE);
}
}
net = socket(AF_INET, SOCK_STREAM, 0);
DpsSockOpt(NULL, net);
if(connect(net, (struct sockaddr *)&sa_in, sizeof (sa_in)))
return(DPS_NET_CANT_CONNECT);
return(net);
}
/*
* allocateMoreSlots is called when there are only enough slot structures
* left to support the allocation of a single malloc buffer.
*/
static void
allocateMoreSlots(void)
{
size_t newSize = allocationListSize + bytesPerPage;
void * newAllocation;
void * oldAllocation = allocationList;
Page_AllowAccess(allocationList, allocationListSize);
noAllocationListProtection = 1;
internalUse = 1;
newAllocation = DpsMalloc(newSize);
dps_memcpy(newAllocation, allocationList, allocationListSize); /* was: dps_memmove */
memset(&(((char *)newAllocation)[allocationListSize]), 0, bytesPerPage);
allocationList = (Slot *)newAllocation;
allocationListSize = newSize;
slotCount += slotsPerPage;
unUsedSlots += slotsPerPage;
/* DpsSort(allocationList, slotCount, sizeof(Slot), (qsort_cmp)cmp_Slot);*/
DpsFree(oldAllocation);
/*
* Keep access to the allocation list open at this point, because
* I am returning to memalign(), which needs that access.
*/
noAllocationListProtection = 0;
internalUse = 0;
}
ssize_t DpsSearchdSendPacket(int fd,const DPS_SEARCHD_PACKET_HEADER *hdr,const void *data){
ssize_t nsent = 0;
if (data == NULL) {
nsent = DpsSend(fd, hdr, sizeof(*hdr), 0);
} else {
char *ldata = (char*)DpsMalloc(sizeof(*hdr) + hdr->len);
if (ldata != NULL) {
dps_memcpy(ldata, hdr, sizeof(*hdr));
dps_memcpy(ldata + sizeof(*hdr), data, hdr->len);
nsent = DpsSend(fd, ldata, sizeof(*hdr) + hdr->len, 0);
}
DPS_FREE(ldata);
}
return nsent;
}
extern C_LINKAGE char * _DpsStrdup(const char *str, const char *filename, size_t fileline) {
size_t len;
char *copy;
len = dps_strlen(str) + 1;
if ((copy = _DpsMalloc(len, filename, fileline)) == NULL)
return (NULL);
dps_memcpy(copy, str, len); /* was: dps_memmove */
return (copy);
}
dpsunicode_t *DpsUniDup(const dpsunicode_t *s) {
dpsunicode_t *res;
size_t size;
size = (DpsUniLen(s)+1)*sizeof(*s);
if((res=(dpsunicode_t*)DpsMalloc(size)) == NULL)
return(NULL);
dps_memcpy(res, s, size); /* was: dps_memmove */
return res;
}
static void DpsChineseSortForLast(DPS_CHINAWORD *List, size_t n) {
register size_t l = 0, c, r;
DPS_CHINAWORD T = List[ r = (n - 1) ];
while (l < r) {
c = (l + r) / 2;
if ( cmpchinese(&List[c], &T) < 0) l = c + 1;
else r = c;
}
if (r < (n - 1) && cmpchinese(&List[r], &T) < 0) r++;
if (r == (n - 1)) return;
dps_memcpy(&List[r + 1], &List[r], (n - r - 1) * sizeof(DPS_CHINAWORD)); /* was: dps_memmove */
List[r] = T;
return;
}
extern C_LINKAGE void * _DpsRealloc(void * oldBuffer, size_t newSize, const char *filename, size_t fileline) {
void * newBuffer = 0;
if ( allocationList == 0 )
initialize(); /* This sets EF_ALIGNMENT */
/*
fprintf(stderr, "DpsRealloc: %p at %s:%d\n", oldBuffer, filename, fileline);
*/
lock();
newBuffer = _DpsMalloc(newSize, filename, fileline);
if ( oldBuffer ) {
size_t size;
Slot * slot;
Page_AllowAccess(allocationList, allocationListSize);
noAllocationListProtection = 1;
slot = slotForUserAddress(oldBuffer);
if ( slot == 0 )
EF_Abort("DpsRealloc(%a, %d): address not from DpsMalloc() at %s:%d.", oldBuffer, newSize, filename, fileline);
if ( newSize < (size = slot->userSize) )
size = newSize;
if ( size > 0 )
dps_memcpy(newBuffer, oldBuffer, size); /* was: dps_memmove */
DpsFree(oldBuffer);
noAllocationListProtection = 0;
Page_DenyAccess(allocationList, allocationListSize);
if ( size < newSize )
memset(&(((char *)newBuffer)[size]), 0, newSize - size);
/* Internal memory was re-protected in free() */
}
release();
return newBuffer;
}
int DpsSearchdGetWordResponse(DPS_AGENT *query,DPS_RESULT *Res,DPS_DB *cl) {
DPS_URL_CRD_DB *wrd = NULL;
DPS_URLDATA *udt = NULL;
#ifdef WITH_REL_TRACK
DPS_URLTRACK *trk = NULL;
#endif
DPS_SEARCHD_PACKET_HEADER hdr;
ssize_t nrecv;
char *msg;
int done=0, rc = DPS_OK;
char *wbuf, *p;
DPS_WIDEWORDLIST_EX *wwl;
DPS_WIDEWORD *ww_ex;
DPS_WIDEWORD ww;
size_t i;
TRACE_IN(query, "DpsSearchdGetWordResponse");
Res->total_found=0;
while(!done){
nrecv = DpsRecvall(cl->searchd, &hdr, sizeof(hdr), 360);
if(nrecv!=sizeof(hdr)){
sprintf(query->Conf->errstr,"Received incomplete header from searchd (%d bytes,errno:%d)",(int)nrecv, errno);
TRACE_OUT(query);
return DPS_ERROR;;
}
#ifdef DEBUG_SDP
DpsLog(query, DPS_LOG_ERROR, "Received header cmd=%d len=%d\n",hdr.cmd,hdr.len);
#endif
switch(hdr.cmd){
case DPS_SEARCHD_CMD_ERROR:
msg=(char*)DpsMalloc(hdr.len+1);
if (msg == NULL) {
done = 1;
break;
}
nrecv = DpsRecvall(cl->searchd, msg, hdr.len, 360);
if (nrecv >= 0) {
msg[nrecv]='\0';
sprintf(query->Conf->errstr,"Searchd error: '%s',received:%d", msg, (int)nrecv);
}
rc = DPS_ERROR;
DPS_FREE(msg);
done=1;
break;
case DPS_SEARCHD_CMD_MESSAGE:
msg=(char*)DpsMalloc(hdr.len+1);
if (msg == NULL) {
done = 1;
break;
}
nrecv = DpsRecvall(cl->searchd, msg, hdr.len, 360);
msg[(nrecv >= 0) ? nrecv : 0] = '\0';
if (strncmp(msg, "Total_found", 11) == 0) {
Res->total_found = (size_t)DPS_ATOI(msg + 12);
Res->grand_total = (size_t)DPS_ATOI(strchr(msg + 12, (int)' ') + 1);
}
#ifdef DEBUG_SDP
DpsLog(query, DPS_LOG_ERROR, "Message from searchd: '%s'\n",msg);
#endif
DPS_FREE(msg);
break;
case DPS_SEARCHD_CMD_WORDS:
DPS_FREE(wrd);
wrd=(DPS_URL_CRD_DB*)DpsMalloc(hdr.len + 1);
if (wrd == NULL) {
done = 1;
break;
}
nrecv = DpsRecvall(cl->searchd, wrd, hdr.len, 360);
/*Res->total_found=hdr.len/sizeof(*wrd);*/
Res->num_rows = (nrecv >= 0) ? (size_t)nrecv / sizeof(*wrd) : 0;
#ifdef DEBUG_SDP
DpsLog(query, DPS_LOG_ERROR, "Received words size=%d nwrd=%d\n",hdr.len, Res->num_rows /*Res->total_found*/);
#endif
done=1;
break;
case DPS_SEARCHD_CMD_SUGGEST:
DPS_FREE(Res->Suggest);
Res->Suggest = (char*)DpsMalloc(hdr.len + 1);
if (Res->Suggest == NULL) {
done = 1; break;
}
nrecv = DpsRecvall(cl->searchd, Res->Suggest, hdr.len, 360);
Res->Suggest[(nrecv >=0) ? nrecv : 0] = '\0';
#ifdef DEBUG_SDP
DpsLog(query, DPS_LOG_ERROR, "Received Suggest size=%d\n", hdr.len);
#endif
break;
case DPS_SEARCHD_CMD_PERSITE:
Res->PerSite = (size_t*)DpsMalloc(hdr.len + 1);
if (Res->PerSite == NULL) {
done = 1;
break;
}
nrecv = DpsRecvall(cl->searchd, Res->PerSite, hdr.len, 360);
#ifdef DEBUG_SDP
DpsLog(query, DPS_LOG_ERROR, "Received PerSite size=%d nwrd=%d\n", nrecv, Res->num_rows/*Res->total_found*/);
#endif
break;
case DPS_SEARCHD_CMD_DATA:
udt = (DPS_URLDATA*)DpsMalloc(hdr.len + 1);
if (udt == NULL) {
done = 1;
break;
}
nrecv = DpsRecvall(cl->searchd, udt, hdr.len, 360);
#ifdef DEBUG_SDP
DpsLog(query, DPS_LOG_ERROR, "Received URLDATA size=%d nwrd=%d\n", nrecv, Res->num_rows);
#endif
break;
#ifdef WITH_REL_TRACK
case DPS_SEARCHD_CMD_TRACKDATA:
trk = (DPS_URLTRACK*)DpsMalloc(hdr.len + 1);
if (trk == NULL) {
done = 1;
break;
}
nrecv = DpsRecvall(cl->searchd, trk, hdr.len, 360);
#ifdef DEBUG_SDP
DpsLog(query, DPS_LOG_ERROR, "Received TRACKDATA size=%d nwrd=%d\n", nrecv, Res->num_rows);
#endif
break;
#endif
case DPS_SEARCHD_CMD_WITHOFFSET:
/* Res->offset = 1;*/
break;
case DPS_SEARCHD_CMD_QLC:
if ((p = (char *)DpsXmalloc(hdr.len + 1)) != NULL) {
if (DpsRecvall(cl->searchd, p, hdr.len, 360)) {
DpsVarListReplaceStr(&query->Vars, "q", p);
}
}
DPS_FREE(p);
break;
case DPS_SEARCHD_CMD_WWL:
Res->PerSite = NULL;
if ((wbuf = p = (char *)DpsXmalloc(hdr.len + 1)) != NULL)
if (DpsRecvall(cl->searchd, wbuf, hdr.len, 360)) {
wwl = (DPS_WIDEWORDLIST_EX *)p;
p += sizeof(DPS_WIDEWORDLIST_EX);
#ifdef DEBUG_SDP
DpsLog(query, DPS_LOG_ERROR, "wbuf :%x, wwl: %x, p: %x hdr.len:%d\n", wbuf, wwl, p, hdr.len);
DpsLog(query, DPS_LOG_ERROR, "Received WWL nwords=%d nuniq=%d\n", wwl->nwords, wwl->nuniq);
#endif
/* DpsWideWordListFree(&Res->WWList);*/
for(i = 0; i < wwl->nwords; i++) {
/* ww_ex = (DPS_WIDEWORD_EX *)((void*)&p[0]);*/
dps_memcpy((char*)&ww, p, sizeof(DPS_WIDEWORD_EX));
p += sizeof(DPS_WIDEWORD_EX);
/*
ww.order = ww_ex->order;
ww.order_inquery = ww_ex->order_inquery;
ww.count = ww_ex->count;
ww.len = ww_ex->len;
ww.ulen = ww_ex->ulen;
ww.origin = ww_ex->origin;
ww.crcword = ww_ex->crcword;
*/
ww.word = p;
#ifdef DEBUG_SDP
DpsLog(query, DPS_LOG_ERROR, "Word {%d}: %s\n", ww.len+1, ww.word);
#endif
p += ww.len + 1;
p += sizeof(dpsunicode_t) - ((SDPALIGN)p % sizeof(dpsunicode_t));
ww.uword = (dpsunicode_t*)p;
p += sizeof(dpsunicode_t) * (ww.ulen + 1);
DpsWideWordListAdd(&Res->WWList, &ww, DPS_WWL_STRICT);
}
Res->WWList.nuniq = wwl->nuniq;
DPS_FREE(wbuf);
}
break;
default:
sprintf(query->Conf->errstr,"Unknown searchd response: cmd=%d len=%d",hdr.cmd,hdr.len);
rc = DPS_ERROR;
done=1;
break;
}
}
Res->CoordList.Coords = wrd;
Res->CoordList.Data = udt;
#ifdef WITH_REL_TRACK
Res->CoordList.Track = trk;
#endif
TRACE_OUT(query);
return rc;
}
