static int
sepfield(char *str, int count)
{
char *ptr, *end;
char tmpval[1024];
strcpy(tmpval, str);
ptr = strchr(tmpval, '#');
end = tmpval + strlen(tmpval);
if (ptr)
*ptr = (char) 0;
ptr = strparse(tmpval, PARSE_SEPARATORS);
while (ptr) {
strncpy(field[count], ptr, STRING_MAX - 1);
field[count][STRING_MAX - 1] = (char) 0;
count++;
ptr = strparse((char *) NULL, PARSE_SEPARATORS);
}
#ifdef DEBUG
printf("sepfield: %d\t", count);
for (j = 0; j < count; j++)
printf("->%s<-", field[j]);
printf("\n");
#endif
return count;
}
DIR *opendir(const char *dirname) {
DIR *dirp;
char *list;
dirp = malloc(sizeof(DIR));
if (!dirp) return NULL;
dirp->fd = open(dirname, ACCS_READ);
if (dirp->fd < 0) {
free(dirp);
return NULL;
}
list = rp_list(fd_rp(dirp->fd));
dirp->entryv = strparse(list, "\t");
if (!dirp->entryv) {
free(dirp);
return NULL;
}
dirp->dirpos = 0;
return dirp;
}
DIR *opendir(const char *dirname) {
DIR *dirp;
char *list;
dirp = malloc(sizeof(DIR));
if (!dirp) return NULL;
dirp->fd = open(dirname, STAT_READER);
if (dirp->fd < 0) {
free(dirp);
return NULL;
}
if (!rp_type(fd_rp(dirp->fd), "dir")) {
errno = ENOTDIR;
close(dirp->fd);
free(dirp);
return NULL;
}
list = rp_list(fd_rp(dirp->fd));
dirp->entryv = strparse(list, "\t");
if (!dirp->entryv) {
free(dirp);
return NULL;
}
dirp->dirpos = 0;
return dirp;
}
int
wrd(void)
{
static int nlines;
char *l, *src[13];
int n;
l = Brdline(wr, '\n');
if(l == 0)
return -1;
++nlines;
l[BLINELEN(wr)-1] = 0;
n = strparse(l, src, 13, " ");
if(n != 12 || src[0][0] == 0 || src[0][1] != 0){
fprint(2, "wrap file format error, line %d\n", nlines);
exits("format");
}
wbuf.stype = src[0][0];
wbuf.mark = strtol(src[1], 0, 10);
strncpy(wbuf.sname, src[2], sizeof wbuf.sname);
wbuf.slen = strtol(src[3], 0, 10);
coord(&wbuf.pent[0], &src[4]);
coord(&wbuf.pent[1], &src[8]);
return 0;
}
void readUserObjects(void)
{
FILE *fp;
String atom_name, push_action, label, icon, drag_icon;
char s[MAXAPPSTRINGLEN];
int i, p;
usrObjects.nr = 0;
usrObjects.obj = NULL;
if (!(fp = fopen(resources.usrobj_file, "r")))
{
if (exists(resources.usrobj_file))
error(topShell, "Cannot read object file", resources.usrobj_file);
return;
}
for (i=0; (p = parseObj(fp, &atom_name, &push_action, &label, &icon, &drag_icon)) > 0; i++)
{
usrObjects.obj = (UserObjectRec *) XTREALLOC(usrObjects.obj, (i+1) * sizeof(UserObjectRec));
usrObjects.obj[i].atom_name = XtNewString(strparse(s, atom_name, "\\:"));
if ((usrObjects.obj[i].atom = XmInternAtom(dpy, usrObjects.obj[i].atom_name, False)) == None)
{
XTFREE(usrObjects.obj[i].atom_name);
error(topShell, "Couldn't initialize user defined object", atom_name);
i--;
}
else
{
usrObjects.obj[i].push_action = XtNewString(strparse(s, push_action, "\\:"));
usrObjects.obj[i].label = XtNewString(strparse(s, label, "\\:"));
usrObjects.obj[i].icon = XtNewString(strparse(s, icon, "\\:"));
usrObjects.obj[i].drag_icon = XtNewString(strparse(s, drag_icon, "\\:"));
}
}
if (p == -1)
error(topShell, "Error in objects file:", resources.usrobj_file);
usrObjects.nr = i;
if (fclose(fp))
sysError(topShell, "Error reading objects file:");
}
void readDTIcons(void)
{
FILE *fp;
AppRec app;
char *name, *directory, *fname, *icon, *push_action, *drop_action, *xp, *yp;
char s[MAXAPPSTRINGLEN];
int i, p, x, y;
XtAppAddActions(app_context, icon_actions, XtNumber(icon_actions));
trans = XtParseTranslationTable(icon_translations);
dticons_blocked = False;
if (stat(resources.dticon_file, &dticons_stats) ||
!(fp = fopen(resources.dticon_file, "r")))
{
dticons_readable = False;
error(getAnyShell(), "Cannot read desktop icons from", resources.dticon_file);
return;
}
dticons_readable = True;
for (i=0; (p = parseIcon(fp, &name, &directory, &fname, &icon, &push_action, &drop_action, &xp, &yp)) > 0; i++)
{
dtIcons = (DTIconRec **) XTREALLOC(dtIcons, (i+1) * sizeof(DTIconRec *));
app.name = XtNewString(strparse(s, name, "\\:"));
app.directory = XtNewString(strparse(s, directory, "\\:"));
app.fname = XtNewString(strparse(s, fname, "\\:"));
app.icon = XtNewString(strparse(s, icon, "\\:"));
app.push_action = XtNewString(strparse(s, push_action, "\\:"));
app.drop_action = XtNewString(strparse(s, drop_action, "\\:"));
app.objType = getObjectType(app.push_action);
app.remove_file = False;
if ((x = atoi(strparse(s, xp, "\\:"))) < 0)
x += winInfo.rootWidth - DTICONWIDTH;
if ((y = atoi(strparse(s, yp, "\\:"))) < 0)
y += winInfo.rootHeight - DTICONHEIGHT;
dtIcons[i] = createDTIcon(getAnyShell(), &app, x, y);
dtIcons[i]->save = True;
displayDTIcon(dtIcons[i]);
}
if (p == -1)
error(getAnyShell(), "Error reading desktop icons from", resources.dticon_file);
n_dtIcons = i;
if (fclose(fp))
sysError(getAnyShell(), "Error reading desktop icons:");
}
int StringList::split( const char * pBegin, const char * pEnd, const char * delim )
{
StrParse strparse( pBegin, pEnd, delim );
const char * p;
while( !strparse.isEnd() )
{
p = strparse.trim_parse();
if ( !p )
break;
if ( p != strparse.getStrEnd() )
{
if ( !add( p, strparse.getStrEnd() - p ) )
break;
}
}
return size();
}
static void __event_handler(struct msg *msg) {
event_t hook;
char **argv;
int argc;
argv = strparse((const char*) msg->data, " ");
if (!argv) return;
for (argc = 0; argv[argc]; argc++);
hook = (event_t) (uintptr_t) s_table_get(event_table, argv[0]);
if (hook) {
hook(msg->source, argc, argv);
}
for (argc = 0; argv[argc]; argc++) free(argv[argc]);
free(argv);
free(msg);
}
/***************************************************************************
* ds_streamproc:
*
* Save MiniSEED records in a custom directory/file structure. The
* appropriate directories and files are created if nesecessary. If
* files already exist they are appended to. If 'msr' is NULL then
* ds_shutdown() will be called to close all open files and free all
* associated memory.
*
* This version has been modified from others to add the add the suffix
* integer supplied with ds_streamproc() to the defkey and file name.
*
* Returns 0 on success, -1 on error.
***************************************************************************/
extern int
ds_streamproc (DataStream *datastream, MSRecord *msr, long suffix, int verbose)
{
DataStreamGroup *foundgroup = NULL;
BTime stime;
strlist *fnlist, *fnptr;
char net[3], sta[6], loc[3], chan[4];
char filename[400];
char definition[400];
char pathformat[600];
char tstr[20];
int fnlen = 0;
/* Set Verbosity for ds_ functions */
dsverbose = verbose;
/* Special case for stream shutdown */
if ( ! msr )
{
if ( dsverbose >= 1 )
fprintf (stderr, "Closing archiving for: %s\n", datastream->path );
ds_shutdown ( datastream );
return 0;
}
if ( ! msr->fsdh )
{
fprintf (stderr, "ds_streamproc(): msr->fsdh must be available\n");
return -1;
}
/* Build file path and name from datastream->path */
filename[0] = '\0';
definition[0] = '\0';
snprintf (pathformat, sizeof(pathformat), "%s", datastream->path);
strparse (pathformat, "/", &fnlist);
fnptr = fnlist;
/* Special case of an absolute path (first entry is empty) */
if ( *fnptr->element == '\0' )
{
if ( fnptr->next != 0 )
{
strncat (filename, "/", sizeof(filename));
fnptr = fnptr->next;
}
else
{
fprintf (stderr, "ds_streamproc(): empty path format\n");
strparse (NULL, NULL, &fnlist);
return -1;
}
}
/* Convert normalized starttime to BTime structure */
if ( ms_hptime2btime (msr->starttime, &stime) )
{
fprintf (stderr, "ds_streamproc(): cannot convert start time to separate fields\n");
strparse (NULL, NULL, &fnlist);
return -1;
}
while ( fnptr != 0 )
{
int tdy;
char *w, *p, def;
p = fnptr->element;
/* Special case of no file given */
if ( *p == '\0' && fnptr->next == 0 )
{
fprintf (stderr, "ds_streamproc(): no file name specified, only %s\n",
filename);
strparse (NULL, NULL, &fnlist);
return -1;
}
while ( (w = strpbrk (p, "%#")) != NULL )
{
def = ( *w == '%' );
*w = '\0';
strncat (filename, p, (sizeof(filename) - fnlen));
fnlen = strlen (filename);
w += 1;
switch ( *w )
{
case 'n' :
ms_strncpclean (net, msr->fsdh->network, 2);
strncat (filename, net, (sizeof(filename) - fnlen));
if ( def ) strncat (definition, net, (sizeof(definition) - fnlen));
fnlen = strlen (filename);
p = w + 1;
break;
case 's' :
ms_strncpclean (sta, msr->fsdh->station, 5);
strncat (filename, sta, (sizeof(filename) - fnlen));
if ( def ) strncat (definition, sta, (sizeof(definition) - fnlen));
fnlen = strlen (filename);
p = w + 1;
break;
case 'l' :
ms_strncpclean (loc, msr->fsdh->location, 2);
strncat (filename, loc, (sizeof(filename) - fnlen));
if ( def ) strncat (definition, loc, (sizeof(definition) - fnlen));
fnlen = strlen (filename);
p = w + 1;
break;
case 'c' :
ms_strncpclean (chan, msr->fsdh->channel, 3);
strncat (filename, chan, (sizeof(filename) - fnlen));
if ( def ) strncat (definition, chan, (sizeof(definition) - fnlen));
fnlen = strlen (filename);
p = w + 1;
break;
case 'Y' :
snprintf (tstr, sizeof(tstr), "%04d", (int) stime.year);
strncat (filename, tstr, (sizeof(filename) - fnlen));
if ( def ) strncat (definition, tstr, (sizeof(definition) - fnlen));
fnlen = strlen (filename);
p = w + 1;
break;
case 'y' :
tdy = (int) stime.year;
while ( tdy > 100 )
{
tdy -= 100;
}
snprintf (tstr, sizeof(tstr), "%02d", tdy);
strncat (filename, tstr, (sizeof(filename) - fnlen));
if ( def ) strncat (definition, tstr, (sizeof(definition) - fnlen));
fnlen = strlen (filename);
p = w + 1;
break;
case 'j' :
snprintf (tstr, sizeof(tstr), "%03d", (int) stime.day);
strncat (filename, tstr, (sizeof(filename) - fnlen));
if ( def ) strncat (definition, tstr, (sizeof(definition) - fnlen));
fnlen = strlen (filename);
p = w + 1;
break;
case 'H' :
snprintf (tstr, sizeof(tstr), "%02d", (int) stime.hour);
strncat (filename, tstr, (sizeof(filename) - fnlen));
if ( def ) strncat (definition, tstr, (sizeof(definition) - fnlen));
fnlen = strlen (filename);
p = w + 1;
break;
case 'M' :
snprintf (tstr, sizeof(tstr), "%02d", (int) stime.min);
strncat (filename, tstr, (sizeof(filename) - fnlen));
if ( def ) strncat (definition, tstr, (sizeof(definition) - fnlen));
fnlen = strlen (filename);
p = w + 1;
break;
case 'S' :
snprintf (tstr, sizeof(tstr), "%02d", (int) stime.sec);
strncat (filename, tstr, (sizeof(filename) - fnlen));
if ( def ) strncat (definition, tstr, (sizeof(definition) - fnlen));
fnlen = strlen (filename);
p = w + 1;
break;
case 'F' :
snprintf (tstr, sizeof(tstr), "%04d", (int) stime.fract);
strncat (filename, tstr, (sizeof(filename) - fnlen));
if ( def ) strncat (definition, tstr, (sizeof(definition) - fnlen));
fnlen = strlen (filename);
p = w + 1;
break;
case 'q' :
snprintf (tstr, sizeof(tstr), "%c", msr->dataquality);
strncat (filename, tstr, (sizeof(filename) - fnlen));
if ( def ) strncat (definition, tstr, (sizeof(definition) - fnlen));
fnlen = strlen (filename);
p = w + 1;
break;
case 'L' :
snprintf (tstr, sizeof(tstr), "%d", msr->reclen);
strncat (filename, tstr, (sizeof(filename) - fnlen));
if ( def ) strncat (definition, tstr, (sizeof(definition) - fnlen));
fnlen = strlen (filename);
p = w + 1;
break;
case 'r' :
snprintf (tstr, sizeof(tstr), "%ld", (long int) (msr->samprate+0.5));
strncat (filename, tstr, (sizeof(filename) - fnlen));
if ( def ) strncat (definition, tstr, (sizeof(definition) - fnlen));
fnlen = strlen (filename);
p = w + 1;
break;
case 'R' :
snprintf (tstr, sizeof(tstr), "%.6f", msr->samprate);
strncat (filename, tstr, (sizeof(filename) - fnlen));
if ( def ) strncat (definition, tstr, (sizeof(definition) - fnlen));
fnlen = strlen (filename);
p = w + 1;
break;
case '%' :
strncat (filename, "%", (sizeof(filename) - fnlen));
fnlen = strlen (filename);
p = w + 1;
break;
case '#' :
strncat (filename, "#", (sizeof(filename) - fnlen));
fnlen = strlen (filename);
p = w + 1;
break;
default :
fprintf (stderr, "Unknown layout format code: '%c'\n", *w);
p = w;
break;
}
}
strncat (filename, p, (sizeof(filename) - fnlen));
fnlen = strlen (filename);
/* If not the last entry then it should be a directory */
if ( fnptr->next != 0 )
{
if ( access (filename, F_OK) )
{
if ( errno == ENOENT )
{
if ( dsverbose >= 1 )
fprintf (stderr, "Creating directory: %s\n", filename);
if (mkdir
(filename, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH))
{
fprintf (stderr, "ds_streamproc: mkdir(%s) %s\n", filename, strerror (errno));
strparse (NULL, NULL, &fnlist);
return -1;
}
}
else
{
fprintf (stderr, "%s: access denied, %s\n", filename, strerror(errno));
strparse (NULL, NULL, &fnlist);
return -1;
}
}
strncat (filename, "/", (sizeof(filename) - fnlen));
fnlen++;
}
fnptr = fnptr->next;
}
strparse (NULL, NULL, &fnlist);
/* Add ".suffix" to filename and definition if suffix is not 0 */
if ( suffix )
{
snprintf (tstr, sizeof(tstr), ".%ld", suffix);
strncat (filename, tstr, (sizeof(filename) - fnlen));
strncat (definition, tstr, (sizeof(definition) - fnlen));
fnlen = strlen (filename);
}
/* Make sure the filename and definition are NULL terminated */
*(filename + sizeof(filename) - 1) = '\0';
*(definition + sizeof(definition) -1) = '\0';
/* Check for previously used stream entry, otherwise create it */
foundgroup = ds_getstream (datastream, msr, definition, filename);
if (foundgroup != NULL)
{
/* Write binary data samples to approriate file */
if ( msr->datasamples && msr->numsamples )
{
if ( dsverbose >= 3 )
fprintf (stderr, "Writing binary data samples to data stream file %s\n", filename);
if ( !write (foundgroup->filed, msr->datasamples, msr->numsamples * ms_samplesize(msr->sampletype)) )
{
fprintf (stderr, "ds_streamproc: failed to write binary data samples\n");
return -1;
}
else
{
foundgroup->modtime = time (NULL);
}
}
/* Write the data record to the appropriate file */
else
{
if ( dsverbose >= 3 )
fprintf (stderr, "Writing data record to data stream file %s\n", filename);
if ( !write (foundgroup->filed, msr->record, msr->reclen) )
{
fprintf (stderr, "ds_streamproc: failed to write data record\n");
return -1;
}
else
{
foundgroup->modtime = time (NULL);
}
}
return 0;
}
return -1;
} /* End of ds_streamproc() */
void
main(int argc, char **argv)
{
int id, arc; char *arv[4];
char *l, *name;
chatty = 1;
ARGBEGIN{
case '9':
case 'u':
style = ARGC();
break;
case 'D':
++debug;
break;
}ARGEND
if(argc <= 0){
ids = readunixids("/fd/0", style);
if(ids)
idprint(1, ids);
exits(ids ? 0 : "readunixids");
}
mapinit(argv[0], 0);
in = Bopen("/fd/0", OREAD);
while(l = Brdline(in, '\n')){ /* assign = */
l[Blinelen(in)-1] = 0;
arc = strparse(l, nelem(arv), arv);
if(arc <= 0)
continue;
switch(arv[0][0]){
case 'r':
if(arc < 2)
continue;
mapinit(arv[1], arv[2]);
break;
case 'i':
if(arc < 2)
continue;
id = strtol(arv[1], 0, 10);
name = id2name(pids, id);
print("%d -> %s\n", id, name);
break;
case 'n':
if(arc < 2)
continue;
name = arv[1];
id = name2id(pids, name);
print("%s -> %d\n", name, id);
break;
case 'p':
print("server=%s, client=%s\n", mp->server, mp->client);
break;
case 'P':
idprint(1, *pids);
break;
case 'u':
pids = &mp->u.ids;
print("users...\n");
break;
case 'g':
pids = &mp->g.ids;
print("groups...\n");
break;
}
}
exits(0);
}
void updateIconDisplay(void)
{
struct stat cur;
Boolean reread = False;
if (dticons_blocked) return;
if (resources.check_application_files)
if (dticons_readable)
reread = stat(resources.dticon_file, &cur) || cur.st_ctime >
dticons_stats.st_ctime || cur.st_mtime > dticons_stats.st_mtime;
else
reread = !stat(resources.dticon_file, &cur);
if (reread) {
FILE *fp;
AppRec *app;
char *name, *directory, *fname, *icon, *push_action, *drop_action,
*xp, *yp;
char *nname, *ndirectory, *nfname, *nicon, *npush_action, *ndrop_action;
char s[MAXAPPSTRINGLEN];
int i, j, p, x, y;
zzz();
dticons_readable = !stat(resources.dticon_file, &dticons_stats);
if (!(fp = fopen(resources.dticon_file, "r")))
{
dticons_readable = False;
error(getAnyShell(), "Cannot read desktop icons from",
resources.dticon_file);
i = 0;
goto remove;
}
/* update existing icons/append new ones */
for (i=0; (p = parseIcon(fp, &name, &directory, &fname, &icon,
&push_action, &drop_action, &xp, &yp)) > 0;
i++) {
if ((x = atoi(strparse(s, xp, "\\:"))) < 0)
x += winInfo.rootWidth - DTICONWIDTH;
if ((y = atoi(strparse(s, yp, "\\:"))) < 0)
y += winInfo.rootHeight - DTICONHEIGHT;
nname = XtNewString(strparse(s, name, "\\:"));
ndirectory = XtNewString(strparse(s, directory, "\\:"));
nfname = XtNewString(strparse(s, fname, "\\:"));
nicon = XtNewString(strparse(s, icon, "\\:"));
npush_action = XtNewString(strparse(s, push_action, "\\:"));
ndrop_action = XtNewString(strparse(s, drop_action, "\\:"));
if (i < n_dtIcons) {
DTIconRec *dticon = dtIcons[i];
app = &dticon->app;
if (!(x != dticon->x ||
y != dticon->y ||
strcmp(nname, app->name) ||
strcmp(ndirectory, app->directory) ||
strcmp(nfname, app->fname) ||
strcmp(nicon, app->icon) ||
strcmp(npush_action, app->push_action) ||
strcmp(ndrop_action, app->drop_action))) {
XTFREE(nname);
XTFREE(ndirectory);
XTFREE(nfname);
XTFREE(nicon);
XTFREE(npush_action);
XTFREE(ndrop_action);
continue;
}
XtDestroyWidget(dticon->app.form);
if (dticon->label_mask != None)
freePixmap(dticon->label_mask);
if (dticon->drop_pixmap != None)
freePixmap(dticon->drop_pixmap);
freeApplicationResources(&dticon->app);
} else {
dtIcons = (DTIconRec **) XTREALLOC(dtIcons, (i+1) * sizeof(DTIconRec *));
dtIcons[i] = (DTIconRec *) XtMalloc(sizeof(DTIconRec));
}
app = &dtIcons[i]->app;
app->name = nname;
app->directory = ndirectory;
app->fname = nfname;
app->icon = nicon;
app->push_action = npush_action;
app->drop_action = ndrop_action;
app->objType = getObjectType(app->push_action);
app->remove_file = False;
dtIcons[i]->x = x;
dtIcons[i]->y = y;
readApplicationIcon(getAnyShell(), app, ERR_POPUP);
dtIcons[i]->label_mask = None;
dtIcons[i]->drop_pixmap = None;
dtIcons[i]->moved = False;
dtIcons[i]->save = True;
displayDTIcon(dtIcons[i]);
}
remove:
/* remove any remaining icons */
for (j = i; j < n_dtIcons; j++) {
DTIconRec *dticon = dtIcons[j];
XtDestroyWidget(dticon->shell);
freeApplicationResources(&dticon->app);
if (dticon->label_mask != None)
freePixmap(dticon->label_mask);
if (dticon->drop_pixmap != None)
freePixmap(dticon->drop_pixmap);
XTFREE(dticon);
}
if (i < n_dtIcons)
dtIcons = (DTIconRec **)
XTREALLOC(dtIcons, i * sizeof(DTIconRec *));
n_dtIcons = i;
wakeUp();
if (dticons_readable && p == -1)
error(getAnyShell(), "Error reading desktop icons from",
resources.dticon_file);
if (dticons_readable && fclose(fp))
sysError(getAnyShell(), "Error reading desktop icons:");
}
}
//////////////////////////
// Read header & possible body
//////////////////////////
bool CMimeProtocol::readMimeRequest(int link,CHARPTR *storage,int nMaxSize)
{
int read=0;
int bytes;
// Allocate initial buffer
CHARPTR pszBuffer;
pszBuffer = *storage = coms->Links[link].buffer;
nMaxSize = coms->Links[link].limit;
while(true){
// Read next lot
if((bytes = recvTcp(link,&pszBuffer[read],nMaxSize-read)) < 0)
return false;
// Remote disconnect
if(bytes == 0)
return false;
read+=bytes;
// Check for header & body
CHARPTR ptrHeadEnd=strstr(pszBuffer,"\r\n\r\n");
CHARPTR ptrContLen=strstr(pszBuffer,"Content-Length: ");
int contentLength;
// No header yet
if(!ptrHeadEnd)
return false;
// Header & no-body required
if(!ptrContLen){
*ptrHeadEnd=0;
return true;
}
// Get body length
if(!strparse(ptrContLen,"Content-Length: %1d",&contentLength))
return false;
// Compare strlen of body
int bodyLen = (ptrHeadEnd+=4)-pszBuffer;
// Re-allocate for biggies
if(contentLength > nMaxSize){
// Catch potential memory errors
try{
// Re-alloc & copy current data to new buffer
coms->Links[link].buffer = *storage = new CHAR[nMaxSize=(contentLength+nMaxSize)];
coms->Links[link].limit = nMaxSize;
//*storage = new CHAR[nMaxSize=(contentLength+nMaxSize)];
memcpy(*storage,pszBuffer,read);
// Re-assign
delete [] pszBuffer;
pszBuffer = *storage;
}
catch( ... ){
return false;
}
}
// Check if body there
if(read >= (bodyLen + contentLength)){
ptrHeadEnd[contentLength]=0;
return true;
}
// Expect data (15 seconds ???)
if(!waitForEvent(link,15000))
return false;
}
}
//////////////////////////
// Read header & populate text with body
//////////////////////////
bool CMimeProtocol::readMimeResponse(int link,CHARPTR headers,int size,CHARPTR content)
{
CHAR buffer[CBUFF_HUGE+2];
CHARPTR ptrHeadEnd;
CHARPTR ptrContLen;
int read=0;
int bytes;
// Reset
strcpy(content,"");
strcpy(headers,"");
// 1st read headers
while(true){
// Wait
if(!waitForEvent(link,10000)){
strcpy(content,headers);
return true;
}
// Read next lot
while((bytes = recvTcp(link,&headers[read],size-read)) <= 0){
switch(OSALASTERROR){
// No data to read - try again
case OSAWOULDBLOCK:
if(!waitForEvent(link,2000))
return false;
continue;
// Oh oh
default:
return false;
}
return false;
}
read+=bytes;
headers[read]=0;
// Check for header & body
ptrHeadEnd=strstr(headers,"\r\n\r\n");
// No header yet
if(ptrHeadEnd)
break;
}
ptrContLen=strstr(headers,"Content-Length: ");
int contentLength;
// Terminate
*ptrHeadEnd=0;
// Header & nobody - copy headers
if(!ptrContLen){
// Just keep reading until server closes connection
contentLength=128000;
ptrHeadEnd += strlen("\r\n\r\n");
strcpy(content,ptrHeadEnd);
}
else{
// Get content length
if(!strparse(ptrContLen,"Content-Length: %1d",&contentLength))
return false;
// Skip to start of body
ptrHeadEnd += strlen("\r\n\r\n");
strcpy(content,ptrHeadEnd);
}
// Calculate remaining
read = strlen(ptrHeadEnd);
while(read < contentLength){
// Read next lot
if((bytes = recvTcp(link,buffer,CBUFF_HUGE)) <= 0){
switch(bytes){
// Remote closure
case 0:
return true;
// Error - check
default:
switch(OSALASTERROR){
// No data to read - try again
case OSAWOULDBLOCK:
if(!waitForEvent(link,2000))
return false;
continue;
// Oh oh
default:
return false;
}
break;
}
}
buffer[bytes] = 0;
read+=bytes;
strcat(content,buffer);
}
// Good to go
return true;
}
status_t TGenericDirentParser::AddEntries(const char *strDirList, const char *option)
{
status_t status = B_OK;
uint32 st = 1;
BList list;
BString strdir(strDirList), curdir;
strdir.ReplaceAll("\r\n", "\n");
strdir.ReplaceAll("\r", "\n");
// ftpd から得た NLST 文字列 strDirList を各行に分割して list にポインタを記憶する
char *p = (char *)strdir.String();
while (*p != 0) {
list.AddItem(p);
p = strchr(p, '\n');
if (p == NULL) break;
*p = 0;
p++;
}
// 解析
for(int32 i = 0; i < list.CountItems(); i++) {
p = (char *)list.ItemAt(i);
// 空白行は無視。但し、次行はディレクトリ名と仮定(再帰モード時)
if (strlen(p) == 0) {
st = 0;
continue;
}
if (st == 0) {
st = 1;
if (strcmp(option, "R") == 0) {
curdir.SetTo(p);
if (curdir.String()[curdir.Length() - 1] == ':') curdir.ReplaceLast(":", "");
i++; // ディレクトリ名の次は total または空行なので無視
continue;
}
}
// 先頭文字(即ち permission のファイル属性) が "-", "d", "l", "c" でなければ無視する。
if (strchr("-dlc", *p) == NULL) continue;
uint32 itemCount;
char *dlist[10], *permission, *num, *owner, *group, *cparam, *size, *month, *day, *houryear, *name;
memset(dlist, 0, sizeof(dlist));
if (*p == 'c') {
itemCount = 10;
strparse(p, dlist, &itemCount);
if (itemCount != 10) continue;
permission = dlist[0];
num = dlist[1];
owner = dlist[2];
group = dlist[3];
cparam = dlist[4];
size = dlist[5];
month = dlist[6];
day = dlist[7];
houryear = dlist[8];
name = dlist[9];
} else {
itemCount = 9;
strparse(p, dlist, &itemCount);
if (itemCount != 9) continue;
permission = dlist[0];
num = dlist[1];
owner = dlist[2];
group = dlist[3];
size = dlist[4];
month = dlist[5];
day = dlist[6];
houryear = dlist[7];
name = dlist[8];
}
// 日付・時間を変換
BString strdate, strtime;
if (atoi(houryear) < 1900) {
char stryear[5];
time_t timer;
struct tm *date;
time(&timer);
date = localtime(&timer);
strftime(stryear, sizeof(stryear), "%Y", date);
strdate << stryear;
strtime << " " << houryear;
} else {
strdate << houryear;
}
strdate << "/";
if (strcasecmp("Jan", month) == 0) strdate << "01"; else
if (strcasecmp("Feb", month) == 0) strdate << "02"; else
if (strcasecmp("Mar", month) == 0) strdate << "03"; else
if (strcasecmp("Apr", month) == 0) strdate << "04"; else
if (strcasecmp("May", month) == 0) strdate << "05"; else
if (strcasecmp("Jun", month) == 0) strdate << "06"; else
if (strcasecmp("Jul", month) == 0) strdate << "07"; else
if (strcasecmp("Aug", month) == 0) strdate << "08"; else
if (strcasecmp("Sep", month) == 0) strdate << "09"; else
if (strcasecmp("Oct", month) == 0) strdate << "10"; else
if (strcasecmp("Nov", month) == 0) strdate << "11"; else
if (strcasecmp("Dec", month) == 0) strdate << "12"; else strdate << month;
char strday[3];
sprintf(strday, "%2.2d", atoi(day));
strdate << "/" << strday << strtime;
// リストに追加
status = this->AddEntry(curdir.String(), name, atoi(size), strdate.String(), permission, owner, group);
if (status != B_OK) break;
}
return status;
}
