void
gread_string (gread_state *state)
{
int c = gget ();
switch (c) {
case EOF:
gerror ();
case '"':
{
gstring *string = New gstring (*(state->chars));
delete state->chars;
delete state;
greturn (string);
}
case '\\':
c = gget ();
switch (c) {
case EOF:
gerror ();
case 'n':
state->chars->append ('\n');
ggoto (gread_string, state);
}
// else fall through
default:
state->chars->append (c);
ggoto (gread_string, state);
}
}
/* Function to read header structure from file */
void rdat(int fd,HEADER *head_data) /* jwb 11/05/95 */
/* fd is the file descriptor */
{
int nobytes; /* jwb 11/05/95 */
if((nobytes = lseek(fd, 0L, 2)) < 10*sizeof(int)) /* jwb 09/24/96 */
{
P("Analysis file header is invalid. Abort\n"); /* jwb 09/24/96 */
fflush(stdout); /* jwb 11/05/95 */
exit(1); /* jwb 11/05/95 */
}
lseek(fd, 0L, 0); /* jwb 11/05/95 */
head_data->performer= gstring(fd);
head_data->instrument= gstring(fd);
head_data->date= gstring(fd);
head_data->pitch= gstring(fd);
head_data->dyn= gstring(fd);
head_data->vibra= gstring(fd);
head_data->part= gstring(fd);
head_data->type= gstring(fd);
head_data->comments= gstring(fd);
head_data->andate= gstring(fd);
read(fd,&head_data->interpval,sizeof(float));
read(fd,&head_data->sr,sizeof(float));
read(fd,&head_data->tl,sizeof(float));
read(fd,&head_data->smax,sizeof(float));
read(fd,&head_data->fa,sizeof(float));
read(fd,&head_data->dt,sizeof(float));
read(fd,&head_data->fftlen,sizeof(int));
read(fd,&head_data->nhar,sizeof(int));
read(fd,&head_data->nchans,sizeof(int));
if( read(fd,&head_data->npts,sizeof(int)) <=0 )
{ P("File read error in rdat()\n");
exit(1);
}
/* #ifdef __alpha */ /* jwb 8/12/94 */
/* swap the int & float bytes after reading them in */
data = (int*)&(head_data->interpval); /* jwb 8/12/94 */
for(i=0;i<10;i++) byteswap4(data+i); /* jwb 8/12/94 */
/* #endif */
} /* end rdat() */
static uchar*
convM2AI(uchar *p, int n, AuthInfo **aip)
{
uchar *e = p+n;
AuthInfo *ai;
ai = mallocz(sizeof(*ai), 1);
if(ai == nil)
return nil;
p = gstring(p, e, &ai->cuid);
p = gstring(p, e, &ai->suid);
p = gstring(p, e, &ai->cap);
p = gcarray(p, e, &ai->secret, &ai->nsecret);
if(p == nil)
auth_freeAI(ai);
else
*aip = ai;
return p;
}
static int
dse2psap (struct type_DSE_PSAPaddr *dse, struct PSAPaddr *pa)
{
struct SSAPaddr *sa = &pa -> pa_addr;
struct TSAPaddr *ta = &sa -> sa_addr;
struct member_DSE_0 *nDSE;
bzero ((char *) pa, sizeof *pa);
pa -> pa_selectlen = gstring (pa -> pa_selector,
sizeof pa -> pa_selector,
dse -> pSelector, "psap selector");
sa -> sa_selectlen = gstring (sa -> sa_selector, sizeof sa -> sa_selector,
dse -> sSelector, "ssap selector");
ta -> ta_selectlen = gstring (ta -> ta_selector, sizeof ta -> ta_selector,
dse -> tSelector, "tsap selector");
for (nDSE = dse -> nAddress; nDSE; nDSE = nDSE -> next) {
char *p;
if (ta -> ta_naddr >= NTADDR) {
advise (NULLCP, "too many network addresses");
return NOTOK;
}
p = qb2str (nDSE->member_DSE_1);
if (norm2na (p, nDSE -> member_DSE_1 -> qb_len,
&ta -> ta_addrs[ta -> ta_naddr++]) == NOTOK)
return NOTOK;
free (p);
}
return OK;
}
/*
* no syntactic checks.
* three causes for error:
* 1. message size field is incorrect
* 2. input buffer too short for its own data (counts too long, etc.)
* 3. too many names or qids
* gqid() and gstring() return nil if they would reach beyond buffer.
* main switch statement checks range and also can fall through
* to test at end of routine.
*/
uint
convM2S(uchar *ap, uint nap, Fcall *f)
{
uchar *p, *ep;
uint i, size;
p = ap;
ep = p + nap;
if(p+BIT32SZ+BIT8SZ+BIT16SZ > ep)
return 0;
size = GBIT32(p);
p += BIT32SZ;
if(size < BIT32SZ+BIT8SZ+BIT16SZ)
return 0;
f->type = GBIT8(p);
p += BIT8SZ;
f->tag = GBIT16(p);
p += BIT16SZ;
switch(f->type)
{
default:
return 0;
case Tversion:
if(p+BIT32SZ > ep)
return 0;
f->msize = GBIT32(p);
p += BIT32SZ;
p = gstring(p, ep, &f->version);
break;
case Tflush:
if(p+BIT16SZ > ep)
return 0;
f->oldtag = GBIT16(p);
p += BIT16SZ;
break;
case Tauth:
if(p+BIT32SZ > ep)
return 0;
f->afid = GBIT32(p);
p += BIT32SZ;
p = gstring(p, ep, &f->uname);
if(p == nil)
break;
p = gstring(p, ep, &f->aname);
if(p == nil)
break;
break;
case Tattach:
if(p+BIT32SZ > ep)
return 0;
f->fid = GBIT32(p);
p += BIT32SZ;
if(p+BIT32SZ > ep)
return 0;
f->afid = GBIT32(p);
p += BIT32SZ;
p = gstring(p, ep, &f->uname);
if(p == nil)
break;
p = gstring(p, ep, &f->aname);
if(p == nil)
break;
break;
case Twalk:
if(p+BIT32SZ+BIT32SZ+BIT16SZ > ep)
return 0;
f->fid = GBIT32(p);
p += BIT32SZ;
f->newfid = GBIT32(p);
p += BIT32SZ;
f->nwname = GBIT16(p);
p += BIT16SZ;
if(f->nwname > MAXWELEM)
return 0;
for(i=0; i<f->nwname; i++){
p = gstring(p, ep, &f->wname[i]);
if(p == nil)
break;
}
break;
case Topen:
if(p+BIT32SZ+BIT8SZ > ep)
return 0;
f->fid = GBIT32(p);
p += BIT32SZ;
f->mode = GBIT8(p);
p += BIT8SZ;
break;
case Tcreate:
if(p+BIT32SZ > ep)
return 0;
f->fid = GBIT32(p);
p += BIT32SZ;
p = gstring(p, ep, &f->name);
if(p == nil)
break;
if(p+BIT32SZ+BIT8SZ > ep)
return 0;
f->perm = GBIT32(p);
p += BIT32SZ;
f->mode = GBIT8(p);
p += BIT8SZ;
break;
case Tread:
if(p+BIT32SZ+BIT64SZ+BIT32SZ > ep)
return 0;
f->fid = GBIT32(p);
p += BIT32SZ;
f->offset = GBIT64(p);
p += BIT64SZ;
f->count = GBIT32(p);
p += BIT32SZ;
break;
case Twrite:
if(p+BIT32SZ+BIT64SZ+BIT32SZ > ep)
return 0;
f->fid = GBIT32(p);
p += BIT32SZ;
f->offset = GBIT64(p);
p += BIT64SZ;
f->count = GBIT32(p);
p += BIT32SZ;
if(p+f->count > ep)
return 0;
f->data = (char*)p;
p += f->count;
break;
case Tclunk:
case Tremove:
if(p+BIT32SZ > ep)
return 0;
f->fid = GBIT32(p);
p += BIT32SZ;
break;
case Tstat:
if(p+BIT32SZ > ep)
return 0;
f->fid = GBIT32(p);
p += BIT32SZ;
break;
case Twstat:
if(p+BIT32SZ+BIT16SZ > ep)
return 0;
f->fid = GBIT32(p);
p += BIT32SZ;
f->nstat = GBIT16(p);
p += BIT16SZ;
if(p+f->nstat > ep)
return 0;
f->stat = p;
p += f->nstat;
break;
/*
*/
case Rversion:
if(p+BIT32SZ > ep)
return 0;
f->msize = GBIT32(p);
p += BIT32SZ;
p = gstring(p, ep, &f->version);
break;
case Rerror:
p = gstring(p, ep, &f->ename);
break;
case Rflush:
break;
case Rauth:
p = gqid(p, ep, &f->aqid);
if(p == nil)
break;
break;
case Rattach:
p = gqid(p, ep, &f->qid);
if(p == nil)
break;
break;
case Rwalk:
if(p+BIT16SZ > ep)
return 0;
f->nwqid = GBIT16(p);
p += BIT16SZ;
if(f->nwqid > MAXWELEM)
return 0;
for(i=0; i<f->nwqid; i++){
p = gqid(p, ep, &f->wqid[i]);
if(p == nil)
break;
}
break;
case Ropen:
case Rcreate:
p = gqid(p, ep, &f->qid);
if(p == nil)
break;
if(p+BIT32SZ > ep)
return 0;
f->iounit = GBIT32(p);
p += BIT32SZ;
break;
case Rread:
if(p+BIT32SZ > ep)
return 0;
f->count = GBIT32(p);
p += BIT32SZ;
if(p+f->count > ep)
return 0;
f->data = (char*)p;
p += f->count;
break;
case Rwrite:
if(p+BIT32SZ > ep)
return 0;
f->count = GBIT32(p);
p += BIT32SZ;
break;
case Rclunk:
case Rremove:
break;
case Rstat:
if(p+BIT16SZ > ep)
return 0;
f->nstat = GBIT16(p);
p += BIT16SZ;
if(p+f->nstat > ep)
return 0;
f->stat = p;
p += f->nstat;
break;
case Rwstat:
break;
}
if(p==nil || p>ep)
return 0;
if(ap+size == p)
return size;
return 0;
}
u16 convM2S(u8 *ap, u16 nap, estyx_fcall_t *f)
{
u8 *p, *ep;
u16 i, size;
p = ap;
ep = p + nap;
if(p+BIT32SZ+BIT8SZ+BIT16SZ > ep)
return 0;
size = GBIT32(p);
p += BIT32SZ;
if (size<BIT32SZ+BIT8SZ+BIT16SZ)
return 0;
f->type = GBIT8(p);
p += BIT8SZ;
f->tag = GBIT16(p);
p += BIT16SZ;
switch(f->type) {
default:
return 0;
case Tversion:
if(p+BIT32SZ > ep)
return 0;
f->u.version.msize = GBIT32(p);
p += BIT32SZ;
p = gstring(p, ep, &f->u.version.version);
break;
case Tflush:
if(p+BIT16SZ > ep)
return 0;
f->u.oldtag = GBIT16(p);
p += BIT16SZ;
break;
case Tauth:
if(p+BIT32SZ > ep)
return 0;
f->u.attach.afid = GBIT32(p);
p += BIT32SZ;
p = gstring(p, ep, &f->u.attach.uname);
if(p == nil)
break;
p = gstring(p, ep, &f->u.attach.aname);
if(p == nil)
break;
break;
case Tattach:
if(p+BIT32SZ > ep)
return 0;
f->fid = GBIT32(p);
p += BIT32SZ;
if(p+BIT32SZ > ep)
return 0;
f->u.attach.afid = GBIT32(p);
p += BIT32SZ;
p = gstring(p, ep, &f->u.attach.uname);
if(p == nil)
break;
p = gstring(p, ep, &f->u.attach.aname);
if(p == nil)
break;
break;
case Twalk:
if(p+BIT32SZ+BIT32SZ+BIT16SZ > ep)
return 0;
f->fid = GBIT32(p);
p += BIT32SZ;
f->u.twalk.newfid = GBIT32(p);
p += BIT32SZ;
f->u.twalk.nwname = GBIT16(p);
p += BIT16SZ;
if(f->u.twalk.nwname > MAXWELEM)
return 0;
for(i=0; i<f->u.twalk.nwname; i++){
p = gstring(p, ep, &f->u.twalk.wname[i]);
if(p == nil)
break;
}
break;
case Topen:
if(p+BIT32SZ+BIT8SZ > ep)
return 0;
f->fid = GBIT32(p);
p += BIT32SZ;
f->u.create.mode = GBIT8(p);
p += BIT8SZ;
break;
case Tcreate:
if(p+BIT32SZ > ep)
return 0;
f->fid = GBIT32(p);
p += BIT32SZ;
p = gstring(p, ep, &f->u.create.name);
if(p == nil)
break;
if(p+BIT32SZ+BIT8SZ > ep)
return 0;
f->u.create.perm = GBIT32(p);
p += BIT32SZ;
f->u.create.mode = GBIT8(p);
p += BIT8SZ;
break;
case Tread:
if(p+BIT32SZ+BIT64SZ+BIT32SZ > ep)
return 0;
f->fid = GBIT32(p);
p += BIT32SZ;
f->u.rw.offset = GBIT32(p);
p += BIT64SZ;
f->u.rw.count = GBIT32(p);
p += BIT32SZ;
break;
case Twrite:
if(p+BIT32SZ+BIT64SZ+BIT32SZ > ep)
return 0;
f->fid = GBIT32(p);
p += BIT32SZ;
f->u.rw.offset = GBIT32(p);
p += BIT64SZ;
f->u.rw.count = GBIT32(p);
p += BIT32SZ;
if(p+f->u.rw.count > ep)
return 0;
f->u.rw.data = p;
p += f->u.rw.count;
break;
case Tclunk:
case Tremove:
if(p+BIT32SZ > ep)
return 0;
f->fid = GBIT32(p);
p += BIT32SZ;
break;
case Tstat:
if(p+BIT32SZ > ep)
return 0;
f->fid = GBIT32(p);
p += BIT32SZ;
break;
case Twstat:
if(p+BIT32SZ+BIT16SZ > ep)
return 0;
f->fid = GBIT32(p);
p += BIT32SZ;
f->u.stat.nstat = GBIT16(p);
p += BIT16SZ;
if(p+f->u.stat.nstat > ep)
return 0;
f->u.stat.stat = p;
p += f->u.stat.nstat;
break;
#if 0
// we never receive R packets so no need for this
/*
*/
case Rversion:
if(p+BIT32SZ > ep)
return 0;
f->u.version.msize = GBIT32(p);
p += BIT32SZ;
p = gstring(p, ep, &f->u.version.version);
break;
case Rerror:
p = gstring(p, ep, &f->u.ename);
break;
case Rflush:
break;
case Rauth:
p = gqid(p, ep, &f->u.aqid);
if(p == nil)
break;
break;
case Rattach:
p = gqid(p, ep, &f->u.open.qid);
if(p == nil)
break;
break;
case Rwalk:
if(p+BIT16SZ > ep)
return 0;
f->u.rwalk.nwqid = GBIT16(p);
p += BIT16SZ;
if(f->u.rwalk.nwqid > MAXWELEM)
return 0;
for(i=0; i<f->u.rwalk.nwqid; i++){
p = gqid(p, ep, &f->u.rwalk.wqid[i]);
if(p == nil)
break;
}
break;
case Ropen:
case Rcreate:
p = gqid(p, ep, &f->u.open.qid);
if(p == nil)
break;
if(p+BIT32SZ > ep)
return 0;
f->u.open.iounit = GBIT32(p);
p += BIT32SZ;
break;
case Rread:
if(p+BIT32SZ > ep) return 0;
f->u.rw.count = GBIT32(p);
p += BIT32SZ;
if(p+f->u.rw.count > ep)
return 0;
f->u.rw.data = data;
p += f->u.rw.count;
break;
case Rwrite:
if(p+BIT32SZ > ep)
return 0;
f->u.rw.count = GBIT32(p);
p += BIT32SZ;
break;
case Rclunk:
case Rremove:
break;
case Rstat:
if(p+BIT16SZ > ep)
return 0;
f->u.stat.nstat = GBIT16(p);
p += BIT16SZ;
if(p+f->u.stat.nstat > ep)
return 0;
f->u.stat.stat = p;
p += f->u.stat.nstat;
break;
case Rwstat:
break;
#endif
}
if(p==nil || p>ep)
return 0;
if(ap+size == p)
return size;
return 0;
}
const char *libpbc_config_getstring (pool * p, const char *key,
const char *def)
{
return (gstring (p, key, def));
}
