Subversion Repositories planix.SVN

#include "headers.h"

Rune
smbruneconvert(Rune r, ulong flags)
{
        if (r >= 'a' && r <= 'z' && (flags & SMB_STRING_UPCASE))
                r = toupper(r);
        else if (r == '/' && (flags & SMB_STRING_REVPATH))
                r = '\\';
        else if (r == '\\' && (flags & SMB_STRING_PATH))
                r = '/';
        else if (r == 0xa0 && (flags & SMB_STRING_REVPATH) && smbglobals.convertspace)
                r = ' ';
        else if (r == ' ' && (flags & SMB_STRING_PATH) && smbglobals.convertspace)
                r = 0xa0;
        return r;
}

int
smbucs2len(char *string)
{
        return (string ? utflen(string) : 0) * 2 + 2;
}

int
smbstrlen(char *string)
{
        return (string ? strlen(string) : 0) + 1;
}

int
smbstringlen(SmbPeerInfo *i, char *string)
{
        if (smbglobals.unicode && (i == nil || (i->capabilities & CAP_UNICODE) != 0))
                return smbucs2len(string);
        return  smbstrlen(string);
}

char *
smbstrinline(uchar **bdatap, uchar *edata)
{
        char *p;
        uchar *np;
        np = memchr(*bdatap, 0, edata - *bdatap);
        if (np == nil)
                return nil;
        p = (char *)*bdatap;
        *bdatap = np + 1;
        return p;
}

char *
smbstrdup(uchar **bdatap, uchar *edata)
{
        char *p;
        uchar *np;
        np = memchr(*bdatap, 0, edata - *bdatap);
        if (np == nil)
                return nil;
        p = smbestrdup((char *)(*bdatap));
        *bdatap = np + 1;
        return p;
}

char *
smbstringdup(SmbHeader *h, uchar *base, uchar **bdatap, uchar *edata)
{
        char *p;
        if (h && h->flags2 & SMB_FLAGS2_UNICODE) {
                uchar *bdata = *bdatap;
                uchar *savebdata;
                Rune r;
                int l;
                char *q;

                l = 0;
                if ((bdata - base) & 1)
                        bdata++;
                savebdata = bdata;
                do {
                        if (bdata + 2 > edata)
                                return nil;
                        r = smbnhgets(bdata); bdata += 2;
                        l += runelen(r);
                } while (r != 0);
                p = smbemalloc(l);
                bdata = savebdata;
                q = p;
                do {
                        r = smbnhgets(bdata); bdata += 2;
                        q += runetochar(q, &r);
                } while (r != 0);
                *bdatap = bdata;
                return p;
        }
        return smbstrdup(bdatap, edata);
}

int
smbstrnput(uchar *buf, ushort n, ushort maxlen, char *string, ushort size, int upcase)
{
        uchar *p = buf + n;
        int l;
        l = strlen(string);
        if (l + 1 > size)
                l = size - 1;
        if (n + l + 1 > maxlen)
                return 0;
        if (upcase) {
                int x;
                for (x = 0; x < l; x++)
                        p[x] = toupper(string[x]);
        }
        else
                memcpy(p, string, l);
        
        p += l;
        while (l++ < size)
                *p++ = 0;
        return size;
}

int
smbstrput(ulong flags, uchar *buf, ushort n, ushort maxlen, char *string)
{
        uchar *p = buf + n;
        int l;
        l = string ? strlen(string) : 0;
        if (n + l + ((flags & SMB_STRING_UNTERMINATED) == 0 ? 1 : 0) > maxlen)
                return 0;
        memcpy(p, string, l);
        if (flags & (SMB_STRING_UPCASE | SMB_STRING_PATH | SMB_STRING_REVPATH)) {
                uchar *q;
                for (q = p; q < p + l; q++)
                        if (*q >= 'a' && *q <= 'z' && (flags & SMB_STRING_UPCASE))
                                *q = toupper(*q);
                        else if (*q == '/' && (flags & SMB_STRING_REVPATH))
                                *q = '\\';
                        else if (*q == '\\' && (flags & SMB_STRING_PATH))
                                *q = '/';
        }
        p += l;
        if ((flags & SMB_STRING_UNTERMINATED) == 0)
                *p++ = 0;
        return p - (buf + n);
}

int
smbucs2put(ulong flags, uchar *buf, ushort n, ushort maxlen, char *string)
{
        uchar *p = buf + n;
        int l;
        int align;
        align = (flags & SMB_STRING_UNALIGNED) == 0 && (n & 1) != 0;
        l = string ? utflen(string) * 2 : 0;
        if (n + l + ((flags & SMB_STRING_UNTERMINATED) ? 0 : 2) + align > maxlen)
                return 0;
        if (align)
                *p++ = 0;
        while (string && *string) {
                Rune r;
                int i;
                i = chartorune(&r, string);
                if (flags & SMB_STRING_CONVERT_MASK)
                        r = smbruneconvert(r, flags);
                smbhnputs(p, r);
                p += 2;
                string += i;
        }
        if ((flags & SMB_STRING_UNTERMINATED) == 0) {
                smbhnputs(p, 0);
                p += 2;
        }
        assert(p <= buf + maxlen);
        return p - (buf + n);
}

int
smbstringput(SmbPeerInfo *p, ulong flags, uchar *buf, ushort n, ushort maxlen, char *string)
{
        if (flags & SMB_STRING_UNICODE)
                return smbucs2put(flags, buf, n, maxlen, string);
        if (flags & SMB_STRING_ASCII)
                return smbstrput(flags, buf, n, maxlen, string);
        if (p && (p->capabilities & CAP_UNICODE) != 0)
                return smbucs2put(flags, buf, n, maxlen, string);
        return smbstrput(flags, buf, n, maxlen, string);
}

void
smbstringprint(char **p, char *fmt, ...)
{
        va_list arg;
        if (*p) {
                free(*p);
                *p = nil;
        }
        va_start(arg, fmt);
        *p = vsmprint(fmt, arg);
        va_end(arg);
}