int Dps_ftp_send_cmd(DPS_CONN *connp, const char *cmd) {
char *buf;
size_t len;
connp->err = 0;
len = dps_strlen(cmd)+2;
buf = DpsXmalloc(len+1);
if (buf == NULL) return -1;
dps_snprintf(buf, len+1, "%s\r\n", cmd);
socket_buf_clear(connp);
if (socket_write(connp, buf)){
DPS_FREE( buf);
return -1;
}
#ifdef DEBUG_FTP
fprintf(stderr, "ftp://%s (cmd) : %s", connp->hostname, buf);
/*DpsLog(connp->indexer, DPS_LOG_DEBUG, "ftp://%s (cmd) : %s", connp->hostname, buf);*/
#endif
DPS_FREE(buf);
if (Dps_ftp_read_line(connp))
return -1;
#ifdef DEBUG_FTP
fprintf(stderr, "ftp://%s (reply): %s", connp->hostname, connp->buf);
/*DpsLog(connp->indexer, DPS_LOG_DEBUG, "ftp://%s (reply): %s", connp->hostname, connp->buf);*/
#endif
return(Dps_ftp_get_reply(connp));
}
static void DpsChineseListAddBundle(DPS_CHINALIST *List, DPS_CHINAWORD * chinaword){
unsigned int h;
size_t len;
if (List->nwords + 1 > List->mwords) {
List->mwords += 1024;
List->ChiWord = (DPS_CHINAWORD *)DpsRealloc(List->ChiWord, (List->mwords)*sizeof(DPS_CHINAWORD));
if (List->ChiWord == NULL) {
List->mwords = List->nwords = 0;
return;
}
}
if (List->hash == NULL) {
List->hash = (size_t *)DpsXmalloc(65536 * sizeof(size_t));
if (List->hash == NULL) {
List->mwords = List->nwords = 0;
return;
}
}
List->ChiWord[List->nwords].word = chinaword->word;
List->ChiWord[List->nwords].freq = chinaword->freq;
List->total += chinaword->freq;
h = (unsigned int)(List->ChiWord[List->nwords].word[0] & 0xffff);
if (List->hash[h] < (len = DpsUniLen(List->ChiWord[List->nwords].word))) {
List->hash[h] = len;
}
List->nwords++;
}
int Dps_ftp_login(DPS_CONN *connp, char *user, char *passwd){
char *buf;
char user_tmp[32], passwd_tmp[64];
int code;
size_t len;
DPS_FREE(connp->user);
DPS_FREE(connp->pass);
if (!user)
dps_snprintf(user_tmp, 32, "anonymous");
else {
dps_snprintf(user_tmp, 32, "%s", user);
connp->user = (char*)DpsStrdup(user);
}
if (!passwd)
dps_snprintf(passwd_tmp, 64, "*****@*****.**", PACKAGE, VERSION);
else {
dps_snprintf(passwd_tmp, 32, "%s", passwd);
connp->pass = (char*)DpsStrdup(passwd);
}
len = dps_strlen(user_tmp) + 5 /*dps_strlen("USER ")*/;
buf = (char *) DpsXmalloc(len+1);
if (buf == NULL) return -1;
dps_snprintf(buf, len+1, "USER %s", user_tmp);
code = Dps_ftp_send_cmd(connp, buf);
DPS_FREE(buf);
if (code == -1)
return -1;
else if (code == 2) /* Don't need password */
return 0;
len = dps_strlen(passwd_tmp) + 5 /*dps_strlen("PASS ")*/;
buf = (char *) DpsXmalloc(len+1);
if (buf == NULL) return -1;
dps_snprintf(buf, len+1, "PASS %s", passwd_tmp);
code = Dps_ftp_send_cmd( connp, buf);
DPS_FREE(buf);
if (code > 3)
return -1;
return 0;
}
int Dps_ftp_list(DPS_CONN *c, DPS_CONN *d, char *path, char *filename, size_t max_doc_size){
char *cmd;
size_t len;
if (!filename){
cmd = DpsXmalloc(16);
if (cmd == NULL) return -1;
sprintf(cmd, "LIST");
}else{
len = dps_strlen(filename) + 16;
cmd = DpsXmalloc(len+1);
if (cmd == NULL) return -1;
dps_snprintf(cmd, len+1, "LIST %s", filename);
}
if (Dps_ftp_send_data_cmd(c, d, cmd, max_doc_size)== -1) {
DPS_FREE(cmd);
/*DpsLog(c->indexer, DPS_LOG_DEBUG, "(ftp_list-err)->%s", d->buf);*/
return -1;
}
DPS_FREE(cmd);
return ftp_parse_list(d, path);
}
int Dps_ftp_set_binary(DPS_CONN *c){
char *cmd;
int code;
cmd = DpsXmalloc(7);
if (cmd == NULL) return -1;
sprintf(cmd, "TYPE I");
code = Dps_ftp_send_cmd(c, cmd);
DPS_FREE(cmd);
if (code == -1){
return -1;
}else if ( code >3 ){
c->err = code;
return -1;
}
return 0;
}
int Dps_ftp_get(DPS_CONN *c, DPS_CONN *d, char *path, size_t max_doc_size){
char *cmd;
size_t len;
if (!path)
return -1;
len = dps_strlen(path) + 16;
cmd = DpsXmalloc(len+1);
if (cmd == NULL) return -1;
dps_snprintf(cmd, len+1, "RETR %s", path);
if (Dps_ftp_send_data_cmd(c, d, cmd, max_doc_size) == -1 && d->err != DPS_NET_FILE_TL) {
DPS_FREE(cmd);
return -1;
}
DPS_FREE(cmd);
return 0;
}
int Dps_ftp_mdtm(DPS_CONN *c, char *path){
char *cmd;
int code;
size_t len;
if (!path)
return -1;
len = dps_strlen(path) + 16;
cmd = DpsXmalloc(len+1);
if (cmd == NULL) return -1;
dps_snprintf(cmd, len+1, "MDTM %s", path);
code = Dps_ftp_send_cmd(c, cmd);
DPS_FREE(cmd);
if (code == -1){
return -1;
}else if ( code >3 ){
c->err = code;
return -1;
}
return (DpsFTPDate2Time_t(c->buf));
}
int Dps_ftp_cwd(DPS_CONN *c, char *path){
char *cmd;
int code;
size_t len;
if (!path)
return -1;
if (*path == '\0') return 0;
len = dps_strlen(path) + 16;
cmd = DpsXmalloc(len+1);
if (cmd == NULL) return -1;
dps_snprintf(cmd, len+1, "CWD %s", path);
code = Dps_ftp_send_cmd(c, cmd);
DPS_FREE(cmd);
if (code == -1){
return -1;
}else if ( code >3 ){
c->err = code;
return -1;
}
return 0;
}
ssize_t Dps_ftp_size(DPS_CONN *c, char *path) {
char *cmd;
int code;
size_t len;
if (!path)
return -1;
len = dps_strlen(path) + 16;
cmd = DpsXmalloc(len + 1);
if (cmd == NULL) return -1;
dps_snprintf(cmd, len + 1, "SIZE %s", path);
code = Dps_ftp_send_cmd(c, cmd);
DPS_FREE(cmd);
if (code == -1){
return -1;
}else if ( code >3 ){
c->err = code;
return -1;
}
sscanf(c->buf, "213 %u", &len);
return len;
}
dpsunicode_t *DpsSegmentByFreq(DPS_CHINALIST *List, dpsunicode_t *line) {
dpsunicode_t *out, *mid, *last, *sentence, *segmented_sentence, part;
size_t i, j, l, a;
int /*reg = 1,*/ ctype, have_bukva_forte, fb_type;
dpsunicode_t space[] = { 32, 0 };
l = 2 * (DpsUniLen(line) + 1);
if (l < 2) return NULL;
out = (dpsunicode_t*)DpsMalloc(l * sizeof(dpsunicode_t));
if (out == NULL) return NULL;
*out = '\0';
mid = (dpsunicode_t*)DpsXmalloc(l * sizeof(dpsunicode_t));
if (mid == NULL) { DPS_FREE(out); return NULL; }
*mid = '\0';
for (i = j = 0; i < DpsUniLen(line); i++) {
/* if (line[i] >= 0x80) {
if (reg == 0) {
mid[j++] = *space;
reg = 1;
}
} else {
if (reg == 1) {
mid[j++] = *space;
reg = 0;
}
}*/
mid[j++] = line[i];
}
/* mid[j] = 0;*/
for (sentence = DpsUniGetSepToken(/*line*/ mid, &last, &ctype, &have_bukva_forte, 0);
sentence;
sentence = DpsUniGetSepToken(NULL, &last, &ctype, &have_bukva_forte, 0)) {
part = *last;
*last = 0;
fb_type = DpsUniCType(*sentence);
if (fb_type > DPS_UNI_BUKVA || fb_type == 2 || fb_type == 1) {
a = 2 * (DpsUniLen(sentence) + 1);
j = DpsUniLen(out);
if (j + a >= l) {
l = j + a + 1;
out = (dpsunicode_t*)DpsRealloc(out, l * sizeof(dpsunicode_t));
if (out == NULL) {
DPS_FREE(mid); return NULL;
}
}
if (*out) DpsUniStrCat(out, space);
DpsUniStrCat(out, sentence);
} else {
if ((segmented_sentence = DpsSegmentProcess(List, sentence)) != NULL) {
a = 2 * (DpsUniLen(segmented_sentence) + 1);
j = DpsUniLen(out);
if (j + a >= l) {
l = j + a + 1;
out = (dpsunicode_t*)DpsRealloc(out, l * sizeof(dpsunicode_t));
if (out == NULL) {
DPS_FREE(mid); return NULL;
}
}
if (*out) DpsUniStrCat(out, space);
DpsUniStrCat(out, segmented_sentence);
DPS_FREE(segmented_sentence);
} else {
DPS_FREE(mid); return NULL;
}
}
*last = part;
}
DPS_FREE(mid);
return out;
}
static dpsunicode_t *DpsSegmentProcess(DPS_CHINALIST *List, dpsunicode_t *line) {
int top, nextid, *position, *next, len, maxid, i, current, father, needinsert, iindex;
unsigned int h;
double *value, p;
dpsunicode_t **result;
dpsunicode_t *otv, space[] = {32, 0};
DPS_CHINAWORD *chinaword, chiw;
if (/*(line[0] >= 0x80) &&*/ (List->hash != NULL)) {
len = DpsUniLen(line);
maxid = 2 * len + 1;
position = (int*)DpsMalloc(maxid * sizeof(int));
if (position == NULL) return NULL;
next = (int*)DpsMalloc(maxid * sizeof(int));
if (next == NULL) {
DPS_FREE(position);
return NULL;
}
value = (double*)DpsMalloc(maxid * sizeof(double));
if (value == NULL) {
DPS_FREE(position); DPS_FREE(next);
return NULL;
}
result = (dpsunicode_t **)DpsMalloc(maxid * sizeof(dpsunicode_t *));
if (result == NULL) {
DPS_FREE(position); DPS_FREE(next); DPS_FREE(value);
return NULL;
}
top = 0;
/* value[0] = 1;*/
value[0] = 1.0 * List->total * len;
position[0] = 0;
next[0] = -1;
result[0] = (dpsunicode_t*)DpsUniDup(&space[1]);
nextid = 1;
/* fprintf(stderr, "SegmentProcess start: len -- %d\n", len);*/
while ((top != -1) && (!((position[top] >= len) && (next[top] == -1)))) {
/* fprintf(stderr, "top: %d position: %d (len: %d) next:%d\n", top, position[top], len, next[top]);*/
/* # find the first open path */
current = top;
father = top;
while ((current != -1) && (position[current] >= len)) {
father = current;
current = next[current];
}
/* # remove this path */
if (current == top) {
top = next[top];
} else {
next[father] = next[current];
}
if (current == -1) {
/* # no open path, finished, take the first path */
next[top] = -1;
} else {
otv = &line[position[current]];
h = (unsigned int)(otv[0] & 0xffff);
/* # if the first character doesn't have word phrase in the dict.*/
if (List->hash[h] == 0) {
List->hash[h] = 1 /*2*/;
}
i = List->hash[h];
if (i + position[current] > len) {
i = len - position[current];
}
/*i = i + 1*/ /*2*/;
otv = NULL;
for (; i > 0; i-- /*2*/) {
/*i = i - 1*/ /*2*/;
DPS_FREE(otv);
otv = DpsUniNDup(&line[position[current]], (size_t)i);
chinaword = DpsChineseListFind(List, otv);
if (i == 1 /*2*/ && chinaword == NULL) {
DPS_FREE(otv);
otv = DpsUniNDup(&line[position[current]], 1/*2*/);
chiw.word = otv;
chiw.freq = 1;
DpsChineseListAdd(List, chinaword = &chiw);
/* DpsChineseListSort(List);*/
/*i = 1*//*2*//*;*/
}
if ((chinaword != NULL) && chinaword->freq) {
/* # pronode() */
/* value[nextid] = value[current] * chinaword->freq / List->total;*/
p = (double)chinaword->freq / List->total;
value[nextid] = value[current] / (-1.0 * log(p) / log(10.0));
position[nextid] = position[current] + i;
h = DpsUniLen(result[current]) + DpsUniLen(otv) + 2;
result[nextid] = (dpsunicode_t*)DpsXmalloc((size_t)h * sizeof(dpsunicode_t));
if (result[nextid] == NULL) {
DPS_FREE(position); DPS_FREE(next); DPS_FREE(value); DPS_FREE(result);
return NULL;
}
DpsUniStrCpy(result[nextid], result[current]);
DpsUniStrCat(result[nextid], space);
DpsUniStrCat(result[nextid], otv);
/*
# check to see whether there is duplicated path
# if there is a duplicate path, remove the small value path
*/
needinsert = 1;
iindex = top;
father = top;
while (iindex != -1) {
if (position[iindex] == position[nextid]) {
if (0.85 * value[iindex] >= value[nextid]) {
needinsert = 0;
} else {
if (top == iindex) {
next[nextid] = next[iindex];
top = nextid;
needinsert = 0;
/* } else {
next[nextid] = next[father];*/ /* next[father] = next[nextid];*/
}
}
iindex = -1;
} else {
father = iindex;
iindex = next[iindex];
}
}
/* # insert the new path into the list */
/* fprintf(stderr, "current:%d position:%d i:%d value[current]:%.12lf nextid:%d value[nextid]:%.12lf\n",
current, position[current], i, value[current], nextid, value[nextid]);*/
if (needinsert == 1) {
while ((iindex != -1) && (value[iindex] > value[nextid])) {
father = iindex;
iindex = next[iindex];
}
if (top == iindex) {
next[nextid] = top;
top = nextid;
} else {
next[father] = nextid;
next[nextid] = iindex;
}
}
nextid++;
if (nextid >= maxid) {
maxid +=128;
position = (int*)DpsRealloc(position, maxid * sizeof(int));
next = (int*)DpsRealloc(next, maxid * sizeof(int));
value = (double*)DpsRealloc(value, maxid * sizeof(double));
result = (dpsunicode_t **)DpsRealloc(result, maxid * sizeof(dpsunicode_t *));
if (position == NULL || next == NULL || value == NULL || result == NULL) {
DPS_FREE(position); DPS_FREE(next); DPS_FREE(value);
if (result != NULL) {
for (i = 0; i < nextid; i++) {
if (i != top) DPS_FREE(result[i]);
}
DPS_FREE(result);
}
return NULL;
}
}
}
} /*while ((i >= 1) && ( chinaword == NULL));*/
DPS_FREE(otv);
}
}
DPS_FREE(position); DPS_FREE(next);
for (i = 0; i < nextid; i++) {
if (i != top) DPS_FREE(result[i]);
}
otv = result[top];
DPS_FREE(value); DPS_FREE(result);
return otv;
} else {
return (dpsunicode_t*)DpsUniDup(line);
}
}
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;
}
static int ftp_parse_list(DPS_CONN *connp, char *path){
char *line, *buf_in, *ch, *buf_out, *tok, *fname;
int len_h, len_f,len_p, i;
char *dir, savec;
size_t len,buf_len,cur_len;
if (!connp->buf || !connp->buf_len)
return 0;
buf_in = connp->buf;
/* 22 = dps_strlen(<a href=\"ftp://%s%s%s/\"></a>)*/
len_h = dps_strlen(connp->hostname) + ((connp->user) ? dps_strlen(connp->user) : 0) + ((connp->pass) ? dps_strlen(connp->pass) : 0) + 2 + 22;
len_p = dps_strlen(path);
cur_len = 0;
buf_len = connp->buf_len;
buf_out = DpsXmalloc(buf_len + 1);
if (buf_out == NULL) return -1;
buf_out[0] = '\0';
line = dps_strtok_r(buf_in, "\r\n", &tok, &savec);
do{
if (!(fname = strtok(line, " ")))
continue;
/* drwxrwxrwx x user group size month date time file_name */
for(i=0; i<7; i++)
if (!(fname = strtok(NULL, " ")))
break;
if (!(fname = strtok(NULL, "")))
continue;
len = 0 ;
len_f = len_h + len_p + dps_strlen(fname);
if ((cur_len+len_f) >= buf_len){
buf_len += DPS_NET_BUF_SIZE;
buf_out = DpsXrealloc(buf_out, buf_len + 1);
}
switch (line[0]){
case 'd':
if (!fname || !strcmp(fname, ".") || !strcmp(fname, ".."))
break;
len = len_f;
dps_snprintf(DPS_STREND(buf_out) /*buf_out+cur_len*/, len+1, "<a href=\"ftp://%s%s%s%s%s/%s%s/\"></a>\n",
(connp->user) ? connp->user : "", (connp->user) ? ":" : "",
(connp->pass) ? connp->pass : "", (connp->user || connp->pass) ? "@" : "",
connp->hostname, path, fname);
break;
case 'l':
ch = strstr (fname, " -> ");
if (!ch)
break;
len = ch - fname;
dir = DpsMalloc(len+1);
if (dir == NULL) return -1;
dps_snprintf(dir, len+1, "%s", fname);
len = len_h + len_p + dps_strlen(dir);
dps_snprintf(DPS_STREND(buf_out)/*buf_out+cur_len*/, len+1, "<a href=\"ftp://%s%s%s%s%s/%s%s/\"></a>\n",
(connp->user) ? connp->user : "", (connp->user) ? ":" : "",
(connp->pass) ? connp->pass : "", (connp->user || connp->pass) ? "@" : "",
connp->hostname, path, dir);
DPS_FREE(dir);
/*ch +=4;*/
/* Check if it is absolute link */
/* if ((ch[0] == '/') || (ch[0] == '\\') ||
((isalpha(ch[0]) && (ch[1]==':')))){
len = len_h+dps_strlen(ch);
dps_snprintf(buf_out+cur_len, len+1, "<a href=\"ftp://%s%s/\"></a>",
connp->hostname, ch);
}else{
len = len_h+len_p+dps_strlen(ch);
dps_snprintf(buf_out+cur_len, len+1, "<a href=\"ftp://%s%s%s/\"></a>",
connp->hostname, path, ch);
}
*/
break;
case '-':
len = len_f;
dps_snprintf(DPS_STREND(buf_out)/*buf_out+cur_len*/, len+1, "<a href=\"ftp://%s%s%s%s%s/%s%s\"></a>\n",
(connp->user) ? connp->user : "", (connp->user) ? ":" : "",
(connp->pass) ? connp->pass : "", (connp->user || connp->pass) ? "@" : "",
connp->hostname, path, fname);
break;
}
cur_len += len;
}while( (line = dps_strtok_r(NULL, "\r\n", &tok, &savec)));
if (cur_len+1 > connp->buf_len_total){
connp->buf_len_total = cur_len;
connp->buf = DpsXrealloc(connp->buf, (size_t)connp->buf_len_total+1);
if (connp->buf == NULL) return -1;
}
bzero(connp->buf, ((size_t)connp->buf_len_total+1));
dps_memmove(connp->buf, buf_out, cur_len);
DPS_FREE(buf_out);
return 0;
}
extern __C_LINK int __DPSCALL DpsBaseOptimize(DPS_BASE_PARAM *P, int sbase) {
struct stat sb;
urlid_t base, base_from, base_to;
long unsigned ActualSize, OriginalSize, i, nitems;
off_t pos, posold, NewItemPos, SSize;
dps_uint8 diff, gain;
double dr = 0.0, cr = 0.0;
ssize_t nread; size_t rsize;
ssize_t wr;
int OptimizeRatio, res, error_cnt;
char buffer[BUFSIZ];
DPS_BASEITEM *hTable;
DPS_SORTBASEITEM *si = NULL;
OptimizeRatio = DpsVarListFindInt(&P->A->Vars, "OptimizeRatio", 15);
P->mode = DPS_WRITE_LOCK;
if (sbase == -1) {
base_from = 0; base_to = (urlid_t)P->NFiles;
} else {
base_from = sbase; base_to = sbase + 1;
}
for (base = base_from; base < base_to; base++) {
error_cnt = 0;
gain = (dps_uint8)0;
P->rec_id = ((base & DPS_BASE_MASK) << DPS_BASE_BITS);
if (DpsBaseOpen(P, DPS_WRITE_LOCK) != DPS_OK) {
DpsLog(P->A, DPS_LOG_ERROR, "Can't open base %s/%s {%s:%d}", P->subdir, P->basename, __FILE__, __LINE__);
DpsBaseClose(P);
return DPS_ERROR;
}
if (lseek(P->Ifd, (off_t)0, SEEK_SET) == (off_t)-1) {
DpsLog(P->A, DPS_LOG_ERROR, "Can't seek %s {%s:%d}", P->Ifilename, __FILE__, __LINE__);
DpsBaseClose(P);
return DPS_ERROR;
}
if (fstat(P->Sfd, &sb) == 0) {
SSize = sb.st_size;
} else {
if ((SSize = (off_t)lseek(P->Sfd, (off_t)0, SEEK_END)) == (off_t)-1) {
DpsLog(P->A, DPS_LOG_ERROR, "Can't seek %s {%s:%d}", P->Sfilename, __FILE__, __LINE__);
DpsBaseClose(P);
return DPS_ERROR;
}
}
nitems = 0;
ActualSize = 0;
OriginalSize = 0;
while(read(P->Ifd, &P->Item, sizeof(DPS_BASEITEM)) == sizeof(DPS_BASEITEM)) {
nitems++;
if ((P->Item.rec_id != 0) && ((dps_uint8)P->Item.offset < (dps_uint8)SSize) && (P->Item.size > 0)) {
ActualSize += (long unsigned)P->Item.size;
OriginalSize += (long unsigned)(P->Item.orig_size ? P->Item.orig_size : P->Item.size);
}
}
if (ftruncate(P->Ifd, (off_t)(nitems * sizeof(DPS_BASEITEM))) != 0) {
dps_strerror(P->A, DPS_LOG_EXTRA, "ftruncate error (pos:%ld) [%s:%d]", (off_t)(nitems * sizeof(DPS_BASEITEM)), __FILE__, __LINE__);
}
dr = (nitems) ? fabs(100.0 * ((long unsigned)SSize - ActualSize) / ((double)SSize + 1.0)) : 0.0;
cr = (nitems) ? fabs(100.0 * ActualSize / (OriginalSize + 1)) : 0.0;
DpsLog(P->A, DPS_LOG_EXTRA, "Optimize: %s/%s base 0x%X, %ld recs defrag: %.2f%% Ratio: %.2f%% Data: %ld File: %ld",
P->subdir, P->basename, P->FileNo, nitems, dr, cr, ActualSize, (long)SSize);
if ((dr >= (double)OptimizeRatio) || (ActualSize == 0 && SSize != 0)) {
si = (DPS_SORTBASEITEM*)DpsMalloc((nitems + 1) * sizeof(DPS_SORTBASEITEM));
if (si == NULL) {
DpsLog(P->A, DPS_LOG_ERROR, "Can't alloc si (%d bytes) at {%s:%d}", (nitems + 1) * sizeof(DPS_SORTBASEITEM), __FILE__, __LINE__);
DpsBaseClose(P);
return DPS_ERROR;
}
if (lseek(P->Ifd, (off_t)0, SEEK_SET) == (off_t)-1) {
DpsLog(P->A, DPS_LOG_ERROR, "Can't seek %s {%s:%d}", P->Ifilename, __FILE__, __LINE__);
DpsBaseClose(P);
DPS_FREE(si);
return DPS_ERROR;
}
for (i = 0; (i < nitems) && (read(P->Ifd, &si[i].Item, sizeof(DPS_BASEITEM)) == sizeof(DPS_BASEITEM)); ) {
if(si[i].Item.rec_id != 0 && ((dps_uint8)si[i].Item.offset < (dps_uint8)SSize) && (si[i].Item.size > 0) && (si[i].Item.size < ActualSize) ) {
i++;
}
}
if (i < nitems) nitems = i;
if (nitems > 1) DpsSort((void*)si, (size_t)nitems, sizeof(DPS_SORTBASEITEM), cmpsi);
gain = (dps_uint8)0;
pos = (off_t)0;
posold = (off_t)0;
if (nitems > 0) {
if ((long unsigned)si[0].Item.offset < (long unsigned)SSize) {
posold = (off_t)si[0].Item.offset;
} else {
si[0].Item.offset = (off_t)0;
si[0].Item.size = 0;
}
}
if (nitems > 1) {
if (si[0].Item.size > (rsize = (size_t)(si[1].Item.offset - si[0].Item.offset))) {
DpsLog(P->A, DPS_LOG_ERROR, "si[0] size adjusted by offset: %ld -> %ld", (long)si[0].Item.size, (long)rsize);
si[0].Item.size = rsize;
error_cnt++;
}
}
if ((diff = (dps_uint8)posold) > 0) {
for(
lseek(P->Sfd, posold, SEEK_SET), rsize = 0;
(rsize < si[0].Item.size) && ((nread = read(P->Sfd, buffer,
(rsize + BUFSIZ < si[0].Item.size) ? BUFSIZ : (si[0].Item.size - rsize) )) > 0);
lseek(P->Sfd, posold, SEEK_SET)
) {
lseek(P->Sfd, pos, SEEK_SET);
(void)write(P->Sfd, buffer, (size_t)nread);
rsize += (size_t)nread;
posold += (off_t)nread;
pos += (off_t)nread;
}
si[0].Item.offset = 0;
if (rsize != si[0].Item.size) {
DpsLog(P->A, DPS_LOG_ERROR, "si[0] size adjusted by size: %ld -> %ld", (long)si[0].Item.size, (long)rsize);
si[0].Item.size = rsize;
error_cnt++;
}
gain += diff;
}
if (nitems > 0)
for (i = 0; i < nitems - 1; i++) {
if ((long unsigned)si[i + 1].Item.offset > (long unsigned)SSize) {
DpsLog(P->A, DPS_LOG_ERROR, "si[%ld] too long offset: %ld > %ld, removing", i , (long)si[i + 1].Item.offset, (long)SSize);
si[i + 1].Item.size = 0;
si[i + 1].Item.offset = si[i].Item.offset + si[i].Item.size;
error_cnt++;
} else {
pos = (off_t)(si[i].Item.offset + si[i].Item.size);
posold = (off_t)si[i + 1].Item.offset;
if (i < nitems - 2) {
if (si[i + 1].Item.size > (rsize = (size_t)(si[i + 2].Item.offset - si[i + 1].Item.offset))) {
DpsLog(P->A, DPS_LOG_ERROR, "si[%ld] size adjusted by offset: %ld -> %ld", i + 1, (long)si[i + 1].Item.size, (long)rsize );
si[i + 1].Item.size = rsize;
error_cnt++;
}
}
if ((diff = (dps_uint8)posold - (dps_uint8)pos) > 0) {
for(
lseek(P->Sfd, posold, SEEK_SET), rsize = 0;
(rsize < si[i + 1].Item.size) && ((nread = read(P->Sfd, buffer,
(rsize + BUFSIZ < si[i + 1].Item.size) ? BUFSIZ : (si[i + 1].Item.size - rsize) )) > 0);
lseek(P->Sfd, posold, SEEK_SET)
) {
lseek(P->Sfd, pos, SEEK_SET);
(void)write(P->Sfd, buffer, (size_t)nread);
rsize += (size_t)nread;
posold += (off_t)nread;
pos += (off_t)nread;
}
if (rsize != si[i + 1].Item.size) {
DpsLog(P->A, DPS_LOG_ERROR, "si[%ld] size adjusted by size: %ld -> %ld", i + 1, (long)si[i + 1].Item.size, (long)rsize);
si[i + 1].Item.size = rsize;
error_cnt++;
}
si[i + 1].Item.offset = si[i].Item.offset + si[i].Item.size;
gain += diff;
}
}
}
posold = SSize;
pos = (nitems) ? (off_t)(si[nitems - 1].Item.offset + si[nitems - 1].Item.size) : (off_t)0;
if (ftruncate(P->Sfd, (off_t)(pos)) != 0) {
dps_strerror(P->A, DPS_LOG_ERROR, "ftruncate error (pos:%ld) [%s:%d]", pos, __FILE__, __LINE__);
}
SSize = pos;
if (posold > pos) {
gain += ((dps_uint8)posold - (dps_uint8)pos);
}
/*if (gain != 0 || OptimizeRatio == 0 || error_cnt > 0)*/ {
posold = lseek(P->Ifd, (off_t)0, SEEK_END);
(void)ftruncate(P->Ifd, (off_t)0);
lseek(P->Ifd, (off_t)0, SEEK_SET);
if ((hTable = (DPS_BASEITEM *)DpsXmalloc(sizeof(DPS_BASEITEM) * DPS_HASH_PRIME)) == NULL) {
DpsLog(P->A, DPS_LOG_ERROR, "Memory alloc error hTable: %d bytes", sizeof(DPS_BASEITEM) * DPS_HASH_PRIME);
DpsBaseClose(P);
DPS_FREE(si);
return DPS_ERROR;
}
if ( (wr = write(P->Ifd, hTable, sizeof(DPS_BASEITEM) * DPS_HASH_PRIME)) != sizeof(DPS_BASEITEM) * DPS_HASH_PRIME) {
dps_strerror(P->A, DPS_LOG_ERROR, "[%s:%d] Can't set new index for file %s\nwritten %d bytes of %d",
__FILE__, __LINE__, P->Ifilename, wr, sizeof(DPS_BASEITEM) * DPS_HASH_PRIME);
DPS_FREE(hTable);
DpsBaseClose(P);
DPS_FREE(si);
return DPS_ERROR;
}
DPS_FREE(hTable);
for (i = 0; i < nitems; i++) {
if (si[i].Item.rec_id == 0 || si[i].Item.size == 0) continue;
if ((long)si[i].Item.offset > (long)SSize) {
DpsLog(P->A, DPS_LOG_ERROR, "si[%ld] too long offset: %ld > %ld, removing", i , (long)si[i].Item.offset, (long)SSize);
error_cnt++;
continue;
}
P->rec_id = si[i].Item.rec_id;
if ((res = DpsBaseSeek(P, DPS_WRITE_LOCK)) != DPS_OK) {
DpsBaseClose(P);
DPS_FREE(si);
return res;
}
if (P->Item.rec_id != P->rec_id) {
if (P->mishash && P->Item.rec_id != 0) {
if ((P->Item.next = (dps_uint8)(NewItemPos = lseek(P->Ifd, (off_t)0, SEEK_END))) == (dps_uint8)-1) {
DpsBaseClose(P);
DPS_FREE(si);
return DPS_ERROR;
}
if (lseek(P->Ifd, (off_t)P->CurrentItemPos, SEEK_SET) == (off_t)-1) {
DpsBaseClose(P);
DPS_FREE(si);
return DPS_ERROR;
}
if (write(P->Ifd, &P->Item, sizeof(DPS_BASEITEM)) != sizeof(DPS_BASEITEM)) {
DpsBaseClose(P);
DPS_FREE(si);
return DPS_ERROR;
}
P->CurrentItemPos = (dps_uint8)NewItemPos;
}
}
P->Item = si[i].Item;
P->Item.next = (off_t)0;
if (lseek(P->Ifd, (off_t)P->CurrentItemPos, SEEK_SET) == (off_t)-1) {
DpsLog(P->A, DPS_LOG_ERROR, "Can't seek %s {%s:%d}", P->Ifilename, __FILE__, __LINE__);
DpsBaseClose(P);
DPS_FREE(si);
return DPS_ERROR;
}
if (write(P->Ifd, &P->Item, sizeof(DPS_BASEITEM)) != sizeof(DPS_BASEITEM)) {
DpsLog(P->A, DPS_LOG_ERROR, "Can't write index for file %s {%s:%d}", P->Ifilename, __FILE__, __LINE__);
DpsBaseClose(P);
DPS_FREE(si);
return DPS_ERROR;
}
}
pos = lseek(P->Ifd, (off_t)0, SEEK_END);
gain += ((dps_uint8)posold - (dps_uint8)pos);
DpsLog(P->A, DPS_LOG_DEBUG, "Optimize: %s/%s base 0x%X cleaned, %ld bytes freed", P->subdir, P->basename, base, gain);
}
DPS_FREE(si);
}
if (error_cnt) base--;
DpsBaseClose(P);
}
return DPS_OK;
}
__C_LINK int __DPSCALL DpsBaseOpen(DPS_BASE_PARAM *P, int mode) {
unsigned int hash;
size_t filenamelen, z;
ssize_t wr;
DPS_BASEITEM *hTable;
#ifdef DEBUG_SEARCH
unsigned long total_ticks, stop_ticks, start_ticks = DpsStartTimer();
#endif
TRACE_IN(P->A, "DpsBaseOpen");
if (P->opened) DpsBaseClose(P);
if (P->NFiles == 0) P->NFiles = DpsVarListFindUnsigned(&P->A->Vars, "BaseFiles", 0x100);
P->FileNo = DPS_FILENO(P->rec_id, P->NFiles);
hash = DPS_HASH(P->rec_id);
filenamelen = dps_strlen(P->vardir) + dps_strlen(P->subdir) + dps_strlen(P->indname) + dps_strlen(P->basename) + 48;
if (
((P->Ifilename = (char *)DpsMalloc(filenamelen)) == NULL) ||
((P->Sfilename = (char *)DpsMalloc(filenamelen)) == NULL) ) {
DPS_FREE(P->Ifilename); DPS_FREE(P->Sfilename);
DpsLog(P->A, DPS_LOG_ERROR, "Memory alloc error 2x%d bytes %s:%d", filenamelen, __FILE__, __LINE__);
TRACE_OUT(P->A);
return DPS_ERROR;
}
sprintf(P->Sfilename, "%s/%s/%s%04zx.s", P->vardir, P->subdir, P->basename, P->FileNo);
sprintf(P->Ifilename, "%s/%s/%s%04zx.i", P->vardir, P->subdir, P->indname, P->FileNo);
if ((P->Ifd = DpsOpen2(P->Ifilename, ((mode == DPS_READ_LOCK) ? O_RDONLY : O_RDWR) | DPS_BINARY)) < 0) {
if ((mode == DPS_READ_LOCK) || ((P->Ifd = DpsOpen3(P->Ifilename, O_RDWR | O_CREAT | DPS_BINARY
/*#ifdef O_DIRECT
| O_DIRECT
#endif*/
,
S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH
)) < 0)) {
dps_strerror(P->A, (mode == DPS_READ_LOCK && errno == ENOENT) ? DPS_LOG_DEBUG : DPS_LOG_ERROR, "Can't open/create file %s for %s [%s:%d]",
P->Ifilename, (mode == DPS_READ_LOCK) ? "read" : "write", __FILE__, __LINE__);
DPS_FREE(P->Ifilename); DPS_FREE(P->Sfilename);
TRACE_OUT(P->A);
return DPS_ERROR;
}
#if 1
DPS_GETLOCK(P->A, DPS_LOCK_BASE_N(P->FileNo));
#endif
DpsWriteLock(P->Ifd);
if ((hTable = (DPS_BASEITEM *)DpsXmalloc(sizeof(DPS_BASEITEM) * DPS_HASH_PRIME)) == NULL) {
DpsLog(P->A, DPS_LOG_ERROR, "Memory alloc error hTable: %d bytes", sizeof(DPS_BASEITEM) * DPS_HASH_PRIME);
DpsUnLock(P->Ifd);
#if 1
DPS_RELEASELOCK(P->A, DPS_LOCK_BASE_N(P->FileNo));
#endif
DPS_FREE(P->Ifilename); DPS_FREE(P->Sfilename);
TRACE_OUT(P->A);
return DPS_ERROR;
}
if ( (wr = write(P->Ifd, hTable, sizeof(DPS_BASEITEM) * DPS_HASH_PRIME)) != sizeof(DPS_BASEITEM) * DPS_HASH_PRIME) {
dps_strerror(P->A, DPS_LOG_ERROR, "Can't set new index for file %s\nwritten %d bytes of %d\nIfd:%d hTable:%x",
P->Ifilename, wr, sizeof(DPS_BASEITEM) * DPS_HASH_PRIME, P->Ifd, hTable);
DPS_FREE(hTable);
DpsUnLock(P->Ifd);
#if 1
DPS_RELEASELOCK(P->A, DPS_LOCK_BASE_N(P->FileNo));
#endif
DPS_FREE(P->Ifilename); DPS_FREE(P->Sfilename);
TRACE_OUT(P->A);
return DPS_ERROR;
}
DpsUnLock(P->Ifd);
#if 1
DPS_RELEASELOCK(P->A, DPS_LOCK_BASE_N(P->FileNo));
#endif
DPS_FREE(hTable);
if (lseek(P->Ifd, (off_t)0, SEEK_SET) == (off_t)-1) {
DpsLog(P->A, DPS_LOG_ERROR, "Can't seek for file %s", P->Ifilename);
DPS_FREE(P->Ifilename); DPS_FREE(P->Sfilename);
TRACE_OUT(P->A);
return DPS_ERROR;
}
}
if (!P->A->Flags.cold_var) {
#if 1
DPS_GETLOCK(P->A, DPS_LOCK_BASE_N(P->FileNo));
#endif
switch (mode) {
case DPS_READ_LOCK:
DpsReadLock(P->Ifd);
break;
case DPS_WRITE_LOCK:
DpsWriteLock(P->Ifd);
break;
}
P->locked = 1;
}
if ((P->Sfd = DpsOpen2(P->Sfilename, ((mode == DPS_READ_LOCK) ? O_RDONLY : O_RDWR) | DPS_BINARY
/*#ifdef O_DIRECT
| O_DIRECT
#endif*/
)) < 0) {
if ((mode == DPS_READ_LOCK) || ((P->Sfd = DpsOpen3(P->Sfilename, O_RDWR | O_CREAT | DPS_BINARY
/*#ifdef O_DIRECT
| O_DIRECT
#endif*/
,
S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH
)) < 0)) {
DpsLog(P->A, DPS_LOG_ERROR, "Can't open/create file %s", P->Sfilename);
DPS_FREE(P->Ifilename); DPS_FREE(P->Sfilename);
TRACE_OUT(P->A);
return DPS_ERROR;
}
}
if (!P->A->Flags.cold_var) {
switch(mode) {
case DPS_READ_LOCK:
DpsReadLock(P->Sfd);
break;
case DPS_WRITE_LOCK:
DpsWriteLock(P->Sfd);
break;
}
}
#ifdef DEBUG_SEARCH
stop_ticks = DpsStartTimer();
total_ticks = stop_ticks - start_ticks;
DpsLog(P->A, DPS_LOG_EXTRA, "OpenBase1 %03X in %.5f sec.", P->FileNo, (float)total_ticks / 1000);
#endif
for (z = 0; z < 3; z++) {
/* search rec_id */
if ( (P->CurrentItemPos = (dps_uint8)lseek(P->Ifd, (off_t)(hash * sizeof(DPS_BASEITEM)), SEEK_SET)) == (dps_uint8)-1) {
DpsLog(P->A, DPS_LOG_ERROR, "Can't seeek for file %s", P->Ifilename);
DPS_FREE(P->Ifilename); DPS_FREE(P->Sfilename);
TRACE_OUT(P->A);
return DPS_ERROR;
}
if (read(P->Ifd, &P->Item, sizeof(DPS_BASEITEM)) != sizeof(DPS_BASEITEM)) {
DpsLog(P->A, DPS_LOG_ERROR, "{%s:%d} Can't read index for file %s seek:%ld hash: %u (%d)",
__FILE__, __LINE__, P->Ifilename, P->CurrentItemPos, hash, hash);
bzero(&P->Item, sizeof(P->Item));
/* DPS_FREE(P->Ifilename); DPS_FREE(P->Sfilename);
TRACE_OUT(P->A);
return DPS_ERROR;
*/
}
#ifdef DEBUG_SEARCH
stop_ticks = DpsStartTimer();
total_ticks = stop_ticks - start_ticks;
DpsLog(P->A, DPS_LOG_EXTRA, "OpenBase2 %03X in %.5f sec.", P->FileNo, (float)total_ticks / 1000);
#endif
if (P->Item.rec_id == P->rec_id || P->Item.rec_id == 0) P->mishash = 0;
else P->mishash = 1;
P->PreviousItemPos = P->CurrentItemPos;
if (P->mishash)
while((P->Item.next != 0) && (P->Item.rec_id != P->rec_id)) {
P->PreviousItemPos = P->CurrentItemPos;
P->CurrentItemPos = P->Item.next;
if (lseek(P->Ifd, (off_t)P->CurrentItemPos, SEEK_SET) == (off_t)-1) {
DpsLog(P->A, DPS_LOG_ERROR, "Can't seek for file %s", P->Ifilename);
DPS_FREE(P->Ifilename); DPS_FREE(P->Sfilename);
TRACE_OUT(P->A);
return DPS_ERROR;
}
if ((wr = read(P->Ifd, &P->Item, sizeof(DPS_BASEITEM))) != sizeof(DPS_BASEITEM)) {
if (wr == 0) {
DpsLog(P->A, DPS_LOG_ERROR, "Possible corrupted hash chain for file %s, trying to restore (%s:%d)",
P->Ifilename, __FILE__, __LINE__);
if (lseek(P->Ifd, (off_t)P->PreviousItemPos, SEEK_SET) == (off_t)-1) {
DpsLog(P->A, DPS_LOG_ERROR, "Can't seek for file %s (%s:%d)", P->Ifilename, __FILE__, __LINE__);
DPS_FREE(P->Ifilename); DPS_FREE(P->Sfilename);
TRACE_OUT(P->A);
return DPS_ERROR;
}
if ((wr = read(P->Ifd, &P->Item, sizeof(DPS_BASEITEM))) != sizeof(DPS_BASEITEM)) {
DpsLog(P->A, DPS_LOG_ERROR, "Can't read previous pos for file %s (%s:%d)", P->Ifilename, __FILE__, __LINE__);
DPS_FREE(P->Ifilename); DPS_FREE(P->Sfilename);
TRACE_OUT(P->A);
return DPS_ERROR;
}
P->Item.next = 0;
if (lseek(P->Ifd, (off_t)P->PreviousItemPos, SEEK_SET) == (off_t)-1) {
DpsLog(P->A, DPS_LOG_ERROR, "Can't seeek for file %s (%s:%d)", P->Ifilename, __FILE__, __LINE__);
DPS_FREE(P->Ifilename); DPS_FREE(P->Sfilename);
TRACE_OUT(P->A);
return DPS_ERROR;
}
if ((wr = write(P->Ifd, &P->Item, sizeof(DPS_BASEITEM))) != sizeof(DPS_BASEITEM)) {
DpsLog(P->A, DPS_LOG_ERROR, "Can't write previous pos for file %s (%s:%d)", P->Ifilename, __FILE__, __LINE__);
DPS_FREE(P->Ifilename); DPS_FREE(P->Sfilename);
TRACE_OUT(P->A);
return DPS_ERROR;
}
goto search_again;
} else {
DpsLog(P->A, DPS_LOG_ERROR, "Can't read hash chain for file %s %d of %d bytes (%s:%d)",
P->Ifilename, wr, sizeof(DPS_BASEITEM), __FILE__, __LINE__);
DPS_FREE(P->Ifilename); DPS_FREE(P->Sfilename);
TRACE_OUT(P->A);
return DPS_ERROR;
}
}
#ifdef DEBUG_SEARCH
stop_ticks = DpsStartTimer();
total_ticks = stop_ticks - start_ticks;
DpsLog(P->A, DPS_LOG_EXTRA, "OpenBase3 %03X in %.5f sec.", P->FileNo, (float)total_ticks / 1000);
#endif
}
break;
search_again:;
}
P->opened = 1;
P->mode = mode;
#ifdef DEBUG_SEARCH
stop_ticks = DpsStartTimer();
total_ticks = stop_ticks - start_ticks;
DpsLog(P->A, DPS_LOG_EXTRA, "OpenBase4 %03X in %.5f sec.\n", P->FileNo, (float)total_ticks / 1000);
#endif
/* fprintf(stderr, "Sfd:0x%x - %s\n", P->Sfd, P->Sfilename);
fprintf(stderr, "Ifd:0x%x - %s\n", P->Ifd, P->Ifilename);*/
TRACE_OUT(P->A);
return DPS_OK;
}
