/* packet packing and unpacking */
#include <u.h>
#include <libc.h>
#include <ctype.h>
#include "cifs.h"

void *
pmem(Pkt *p, void *v, int len)
{
       uchar *str = v;
       void *s = p->pos;

       if(!len || !v)
               return s;
       while(len--)
               *p->pos++ = *str++;
       return s;
}

void *
ppath(Pkt *p, char *str)
{
       char c;
       Rune r;
       void *s = p->pos;

       if(!str)
               return s;

       if(p->s->flags2 & FL2_UNICODE){
               if(((p->pos - p->buf) % 2) != 0)        /* pad to even offset */
                       p8(p, 0);
               while(*str){
                       str += chartorune(&r, str);
                       if(r > Bits16)
                               sysfatal("ppath: %C/%x utf too wide for windows\n", r, r);
                       if(r == L'/')
                               r = L'\\';
                       pl16(p, r);
               }
               pl16(p, 0);
       } else {
               while((c = *str++) != 0){
                       if(c == '/')
                               c = '\\';
                       *p->pos++ = c;
               }
               *p->pos++ = 0;
       }
       return s;
}

void *
pstr(Pkt *p, char *str)
{
       void *s = p->pos;
       Rune r;

       if(!str)
               return s;

       if(p->s->flags2 & FL2_UNICODE){
               if(((p->pos - p->buf) % 2) != 0)
                       p8(p, 0);               /* pad to even offset */
               while(*str){
                       str += chartorune(&r, str);
                       if(r > Bits16)
                               sysfatal("pstr: %C/%x utf too wide for windows\n", r, r);
                       pl16(p, r);
               }
               pl16(p, 0);
       } else {
               while(*str)
                       *p->pos++ = *str++;
               *p->pos++ = 0;
       }
       return s;
}

void *
pascii(Pkt *p, char *str)
{
       void *s = p->pos;

       while(*str)
               *p->pos++ = *str++;
       *p->pos++ = 0;
       return s;
}


void *
pl64(Pkt *p, uvlong n)
{
       void *s = p->pos;

       *p->pos++ = n;
       *p->pos++ = n >> 8;
       *p->pos++ = n >> 16;
       *p->pos++ = n >> 24;
       *p->pos++ = n >> 32;
       *p->pos++ = n >> 40;
       *p->pos++ = n >> 48;
       *p->pos++ = n >> 56;
       return s;
}

void *
pb32(Pkt *p, uint n)
{
       void *s = p->pos;

       *p->pos++ = n >> 24;
       *p->pos++ = n >> 16;
       *p->pos++ = n >> 8;
       *p->pos++ = n;
       return s;
}

void *
pl32(Pkt *p, uint n)
{
       void *s = p->pos;

       *p->pos++ = n;
       *p->pos++ = n >> 8;
       *p->pos++ = n >> 16;
       *p->pos++ = n >> 24;
       return s;
}

void *
pb16(Pkt *p, uint n)
{
       void *s = p->pos;

       *p->pos++ = n >> 8;
       *p->pos++ = n;
       return s;
}

void *
pl16(Pkt *p, uint n)
{
       void *s = p->pos;

       *p->pos++ = n;
       *p->pos++ = n >> 8;
       return s;
}

void *
p8(Pkt *p, uint n)
{
       void *s = p->pos;

       *p->pos++ = n;
       return s;
}

/*
* Encode a Netbios name
*/
void *
pname(Pkt *p, char *name, char pad)
{
       int i, done = 0;
       char c;
       void *s = p->pos;

       *p->pos++ = ' ';
       for(i = 0; i < 16; i++) {
               c = pad;
               if(!done && name[i] == '\0')
                       done = 1;
               if(!done)
                       c = islower(name[i])? toupper(name[i]): name[i];
               *p->pos++ = ((uchar)c >> 4) + 'A';
               *p->pos++ = (c & 0xf) + 'A';
       }
       *p->pos++ = '\0';
       return s;
}

void *
pvtime(Pkt *p, uvlong n)
{
       void *s = p->pos;

       n += 11644473600LL;
       n *= 10000000LL;

       pl32(p, n);
       pl32(p, n >> 32);
       return s;
}

void *
pdatetime(Pkt *p, long utc)
{
       void *s = p->pos;
       Tm *tm = localtime(utc);
       int t = tm->hour << 11 | tm->min << 5 | (tm->sec / 2);
       int d = (tm->year - 80) << 9 | (tm->mon + 1) << 5 | tm->mday;

       /*
        * bug in word swapping in Win95 requires this
        */
       if(p->s->caps & CAP_NT_SMBS){
               pl16(p, d);
               pl16(p, t);
       } else{
               pl16(p, t);
               pl16(p, d);
       }
       return s;
}


void
gmem(Pkt *p, void *v, int n)
{
       uchar *str = v;

       if(!n || !v)
               return;
       while(n-- && p->pos < p->eop)
               *str++ = *p->pos++;
}

/*
* note len is the length of the source string in
* in runes or bytes, in ASCII mode this is also the size
* of the output buffer but this is not so in Unicode mode!
*/
static void
_gstr(Pkt *p, char *str, int n, int align)
{
       int i;
       Rune r;

       if(!n || !str)
               return;

       if(p->flags2 & FL2_UNICODE){
               if(((p->pos - p->buf) % 2) != 0){
                       if(align)
                               abort();
               }
               i = 0;
               while(*p->pos && n && p->pos < p->eop){
                       r = gl16(p);
                       i += runetochar(str +i, &r);
                       n -= 2;
               }
               *(str + i) = 0;
               while(*p->pos && p->pos < p->eop)
                       gl16(p);
               /*
                * some versions of windows terminate a rune string
                * with a single nul so we do a dangerous hack...
                */
               if(p->pos[1])
                       g8(p);
               else
                       gl16(p);
       } else {
               while(*p->pos && n-- && p->pos < p->eop)
                       *str++ = *p->pos++;
               *str = 0;
               while(*p->pos++ && p->pos < p->eop)
                       continue;
       }
}

void
gstr(Pkt *p, char *str, int n)
{
       _gstr(p, str, n, 1);
}

void
gstr_noalign(Pkt *p, char *str, int n)
{
       _gstr(p, str, n, 0);
}

/*
* Because DFS uses a string heap rather than strings embedded in the
* data packet, experience (rather than any spec) tells, us we must
* turn off the 16bit alignment for unicode strings.
*/
void
goff(Pkt *p, uchar *base, char *str, int n)
{
       int off;
       uchar *pos;

       off = gl16(p);
       if(off == 0 || base + off > p->eop){
               memset(str, 0, n);
               return;
       }
       pos = p->pos;
       p->pos = base + off;
       gstr_noalign(p, str, n);
       p->pos = pos;
}

void
gascii(Pkt *p, char *str, int n)
{
       if(!n || !str)
               return;

       while(*p->pos && n-- && p->pos < p->eop)
               *str++ = *p->pos++;
       *str = 0;
       while(*p->pos++ && p->pos < p->eop)
               continue;
}


uvlong
gl64(Pkt *p)
{
       uvlong n;

       if(p->pos + 8 > p->eop)
               return 0;

       n  = (uvlong)*p->pos++;
       n |= (uvlong)*p->pos++ << 8;
       n |= (uvlong)*p->pos++ << 16;
       n |= (uvlong)*p->pos++ << 24;
       n |= (uvlong)*p->pos++ << 32;
       n |= (uvlong)*p->pos++ << 40;
       n |= (uvlong)*p->pos++ << 48;
       n |= (uvlong)*p->pos++ << 56;
       return n;
}

uvlong
gb48(Pkt *p)
{
       uvlong n;

       if(p->pos + 6 > p->eop)
               return 0;

       n  = (uvlong)*p->pos++ << 40;
       n |= (uvlong)*p->pos++ << 24;
       n |= (uvlong)*p->pos++ << 32;
       n |= (uvlong)*p->pos++ << 16;
       n |= (uvlong)*p->pos++ << 8;
       n |= (uvlong)*p->pos++;
       return n;
}

uint
gb32(Pkt *p)
{
       uint n;

       if(p->pos + 4 > p->eop)
               return 0;

       n  = (uint)*p->pos++ << 24;
       n |= (uint)*p->pos++ << 16;
       n |= (uint)*p->pos++ << 8;
       n |= (uint)*p->pos++;
       return n;
}

uint
gl32(Pkt *p)
{
       uint n;

       if(p->pos + 4 > p->eop)
               return 0;

       n  = (uint)*p->pos++;
       n |= (uint)*p->pos++ << 8;
       n |= (uint)*p->pos++ << 16;
       n |= (uint)*p->pos++ << 24;
       return n;
}

uint
gb16(Pkt *p)
{
       uint n;

       if(p->pos + 2 > p->eop)
               return 0;
       n  = (uint)*p->pos++ << 8;
       n |= (uint)*p->pos++;
       return n;
}

uint
gl16(Pkt *p)
{
       uint n;

       if(p->pos + 2 > p->eop)
               return 0;
       n  = (uint)*p->pos++;
       n |= (uint)*p->pos++ << 8;
       return n;
}

uint
g8(Pkt *p)
{
       if(p->pos + 1 > p->eop)
               return 0;
       return (uint)*p->pos++;
}

long
gdatetime(Pkt *p)
{
       Tm tm;
       uint d, t;

       if(p->pos + 4 > p->eop)
               return 0;

       /*
        * bug in word swapping in Win95 requires this
        */
       if(p->s->caps & CAP_NT_SMBS){
               d = gl16(p);
               t = gl16(p);
       }else{
               t = gl16(p);
               d = gl16(p);
       }

       memset(&tm, 0, sizeof(tm));
       tm.year = 80 + (d >> 9);
       tm.mon = ((d >> 5) & 017) - 1;
       tm.mday = d & 037;
       tm.zone[0] = 0;
       tm.tzoff = p->s->tz;

       tm.hour = t >> 11;
       tm.min = (t >> 5) & 63;
       tm.sec = (t & 31) << 1;

       return tm2sec(&tm);
}

long
gvtime(Pkt *p)
{
       uvlong vl;

       if(p->pos + 8 > p->eop)
               return 0;

       vl  = (uvlong)gl32(p);
       vl |= (uvlong)gl32(p) << 32;

       vl /= 10000000LL;
       vl -= 11644473600LL;
       return vl;
}

void
gconv(Pkt *p, int conv, char *str, int n)
{
       int off;
       uchar *pos;

       off = gl32(p) & 0xffff;
       if(off == 0 || p->tdata - conv + off > p->eop){
               memset(str, 0, n);
               return;
       }

       pos = p->pos;
       p->pos = p->tdata - conv + off;
       gascii(p, str, n);
       p->pos = pos;
}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.