[doldaconnect.git] / daemon / conf.c

/*
 *  Dolda Connect - Modular multiuser Direct Connect-style client
 *  Copyright (C) 2004 Fredrik Tolf <fredrik@dolda2000.com>
 *  
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *  
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include <stdlib.h>
#include <langinfo.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <errno.h>
#include <wctype.h>
#include <stddef.h>
#include <wchar.h>
#include <iconv.h>
#include <arpa/inet.h>
#include <gdbm.h>

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "conf.h"
#include "log.h"
#include "utils.h"

static struct configmod *modules = NULL;

#if 0
static void dumpconfig(void)
{
    struct configmod *mod;
    struct configvar *var;
    
    for(mod = modules; mod != NULL; mod = mod->next)
    {
	printf("%s:\n", mod->name);
	for(var = mod->vars; var->type != CONF_VAR_END; var++)
	{
	    switch(var->type)
	    {
	    case CONF_VAR_BOOL:
		printf("\t%s: %s\n", var->name, var->val.num?"t":"f");
		break;
	    case CONF_VAR_INT:
		printf("\t%s: %i\n", var->name, var->val.num);
		break;
	    case CONF_VAR_STRING:
		printf("\t%s: \"%ls\" (%i)\n", var->name, var->val.str, wcslen(var->val.str));
		break;
	    case CONF_VAR_IPV4:
		printf("\t%s: %s\n", var->name, inet_ntoa(var->val.ipv4));
		break;
	    }
	}
    }
}
#endif

struct configvar *confgetvar(char *modname, char *varname)
{
    struct configmod *m;
    struct configvar *v;
    
    for(m = modules; m != NULL; m = m->next)
    {
	if(!strcmp(m->name, modname))
	{
	    for(v = m->vars; v->type != CONF_VAR_END; v++)
	    {
		if(!strcmp(v->name, varname))
		    return(v);
	    }
	    break;
	}
    }
    return(NULL);
}

void confregmod(struct configmod *mod)
{
    struct configvar *var;
    
    for(var = mod->vars; var->type != CONF_VAR_END; var++)
    {
	switch(var->type)
	{
	case CONF_VAR_BOOL:
	case CONF_VAR_INT:
	    var->val.num = var->defaults.num;
	    break;
	case CONF_VAR_STRING:
	    if(var->defaults.str != NULL)
	    {
		var->val.str = swcsdup(var->defaults.str);
	    } else {
		var->val.str = NULL;
	    }
	    break;
	case CONF_VAR_IPV4:
	    var->val.ipv4.s_addr = var->defaults.ipv4.s_addr;
	    break;
	}
	CBCHAININIT(var, conf_update);
    }
    mod->next = modules;
    modules = mod;
}

int runconfcmd(int argc, wchar_t **argv)
{
    struct configmod *module;
    struct configvar *var;
    struct configcmd *cmd;
    int ret, handled;
    wchar_t *p;
    char *cmdn, *buf, *buf2, *valbuf;
    long num;
    struct in_addr newipv4;
    int cb;
    
    if(argc < 1)
	return(0);
    if((cmdn = icwcstombs(argv[0], "us-ascii")) == NULL)
    {
	flog(LOG_WARNING, "could not convert %ls to us-ascii", argv[0]);
	return(1);
    }
    ret = 1;
    handled = 0;
    if(!strcmp(cmdn, "set"))
    {
	handled = 1;
	ret = 0;
	if((p = wcschr(argv[1], L'.')) == NULL)
	{
	    flog(LOG_WARNING, "illegal configuration variable format: %ls", argv[1]);
	    errno = EINVAL;
	    free(cmdn);
	    return(1);
	}
	*(p++) = L'\0';
	if((buf = icwcstombs(argv[1], "us-ascii")) == NULL)
	{
	    flog(LOG_WARNING, "could not convert %ls to us-ascii", argv[1]);
	    free(cmdn);
	    return(1);
	}
	if((buf2 = icwcstombs(p, "us-ascii")) == NULL)
	{
	    free(buf);
	    flog(LOG_WARNING, "could not convert %ls to us-ascii", p);
	    free(cmdn);
	    return(1);
	}
	for(module = modules; module != NULL; module = module->next)
	{
	    if(!strcmp(module->name, buf) && (module->vars != NULL))
	    {
		for(var = module->vars; var->type != CONF_VAR_END; var++)
		{
		    if(!strcmp(var->name, buf2))
		    {
			cb = 0;
			switch(var->type)
			{
			case CONF_VAR_BOOL:
			    wcstolower(argv[2]);
			    if(!wcscmp(argv[2], L"off") ||
			       !wcscmp(argv[2], L"false") ||
			       !wcscmp(argv[2], L"no") ||
			       !wcscmp(argv[2], L"0"))
			    {
				if(var->val.num)
				    cb = 1;
				var->val.num = 0;
			    } else if(!wcscmp(argv[2], L"on") ||
				      !wcscmp(argv[2], L"true") ||
				      !wcscmp(argv[2], L"yes") ||
				      !wcscmp(argv[2], L"1")) {
				if(!var->val.num)
				    cb = 1;
				var->val.num = 1;
			    } else {
				flog(LOG_WARNING, "unrecognized boolean: %ls", argv[2]);
			    }
			    break;
			case CONF_VAR_INT:
			    num = wcstol(argv[2], &p, 0);
			    if(p == argv[2])
			    {
				flog(LOG_WARNING, "%ls: not a number, ignoring", argv[2]);
				ret = 1;
			    } else {
				if(*p != L'\0')
				    flog(LOG_WARNING, "%ls: could not entirely parse as a number, ignoring trailing garbage", argv[2]);
				if(num != var->val.num)
				    cb = 1;
				var->val.num = num;
			    }
			    break;
			case CONF_VAR_STRING:
			    if(wcscmp(var->val.str, argv[2]))
				cb = 1;
			    free(var->val.str);
			    var->val.str = swcsdup(argv[2]);
			    break;
			case CONF_VAR_IPV4:
			    if((valbuf = icwcstombs(argv[2], "us-ascii")) == NULL)
			    {
				flog(LOG_WARNING, "could not convert IPv4 address to as-ascii in var %s, ignoring", buf2);
			    } else {
				if(!inet_aton(valbuf, &newipv4))
				{
				    flog(LOG_WARNING, "could not parse IPv4 address (%s), ignoring", valbuf);
				    memcpy(&var->val.ipv4, &var->defaults.ipv4, sizeof(var->val.ipv4));
				} else {
				    if(memcmp(&newipv4, &var->val.ipv4, sizeof(newipv4)))
					cb = 1;
				    memcpy(&var->val.ipv4, &newipv4, sizeof(newipv4));
				}
				free(valbuf);
			    }
			    break;
			}
			if(cb)
			    CBCHAINDOCB(var, conf_update, var);
			break;
		    }
		}
		if(var == NULL)
		    flog(LOG_WARNING, "variable %s not found, ignoring set command", buf2);
		break;
	    }
	}
	if(module == NULL)
	    flog(LOG_WARNING, "module %s not found, ignoring set command", buf);
	free(buf2);
	free(buf);
    }
    for(module = modules; !handled && (module != NULL); module = module->next)
    {
	if(module->cmds != NULL)
	{
	    for(cmd = module->cmds; cmd->name != NULL; cmd++)
	    {
		if(!strcmp(cmd->name, cmdn))
		{
		    handled = 1;
		    ret = cmd->handler(argc, argv);
		    break;
		}
	    }
	}
    }
    if(!handled)
	flog(LOG_WARNING, "command not found: %s", cmdn);
    free(cmdn);
    return(ret);
}

void readconfig(FILE *stream)
{
    int state;
    wint_t c;
    wchar_t *words[16];
    wchar_t *buf, *p, *p2;
    int w;
    int line;
    
    buf = smalloc(sizeof(wchar_t) * 1024);
    state = 0;
    c = getwc(stream);
    w = 0;
    line = 1;
    p = buf;
    while(c != WEOF)
    {
	if(c == '#')
	{
	    do
		c = getwc(stream);
	    while((c != WEOF) && (c != L'\n'));
	    continue;
	}
	switch(state)
	{
	case 0:
	    if(iswspace(c))
	    {
		if(c == L'\n')
		{
		    line++;
		    if(runconfcmd(w, words))
			flog(LOG_WARNING, "ignoring this command on line %i", line);
		    w = 0;
		}
		c = getwc(stream);
	    } else {
		state = 1;
		p2 = p;
	    }
	    break;
	case 1:
	    if(c == L'\"')
	    {
		state = 2;
		c = getwc(stream);
	    } else if(iswspace(c)) {
		if(w >= 16)
		{
		    flog(LOG_WARNING, "too many words on config line %i, ignoring rest", line);
		} else {
		    *(p++) = L'\0';
		    words[w++] = p2;
		}
		state = 0;
	    } else {
		if(c == L'\\')
		    c = getwc(stream);
		if(p - buf < 1023)
		    *(p++) = c;
		else
		    flog(LOG_WARNING, "too many characters on config line %i, ignoring rest", line);
		c = getwc(stream);
	    }
	    break;
	case 2:
	    if(c == L'\"')
	    {
		c = getwc(stream);
		state = 1;
	    } else {
		if(c == L'\\')
		    c = getwc(stream);
		if(p - buf < 1023)
		    *(p++) = c;
		else
		    flog(LOG_WARNING, "too many characters on config line %i, ignoring rest", line);
		c = getwc(stream);
	    }
	    break;
	}
    }
    free(buf);
    if(ferror(stream))
	flog(LOG_WARNING, "error on configuration stream: %s", strerror(errno));
    if(state != 0)
	flog(LOG_WARNING, "unexpected end of file");
}

/* {store,fetch}var re-opens the database every time, just in case two
 * doldacond processes would be running simultaneously. */
void storevar(char *key, void *val, size_t len)
{
    char *dbname;
    GDBM_FILE db;
    datum k, v;
    
    dbname = findfile("dc-vardb", NULL, 1);
    if((db = gdbm_open(dbname, 0, GDBM_WRCREAT, 0666, NULL)) == NULL)
    {
	flog(LOG_CRIT, "could not open var database for writing, cannot continue: %s", gdbm_strerror(gdbm_errno));
	abort();
    }
    free(dbname);
    k.dptr = key;
    k.dsize = strlen(key);
    v.dptr = val;
    v.dsize = len;
    gdbm_store(db, k, v, GDBM_REPLACE);
    gdbm_close(db);
}

void *fetchvar(char *key, size_t *lenb)
{
    char *dbname;
    GDBM_FILE db;
    datum k, v;
    
    if((dbname = findfile("dc-vardb", NULL, 0)) == NULL)
	return(NULL);
    if((db = gdbm_open(dbname, 0, GDBM_READER, 0666, NULL)) == NULL)
	return(NULL);
    free(dbname);
    k.dptr = key;
    k.dsize = strlen(key);
    v = gdbm_fetch(db, k);
    gdbm_close(db);
    if(v.dptr == NULL)
	return(NULL);
    if(lenb != NULL)
	*lenb = v.dsize;
    return(v.dptr);
}
Commit	Line	Data
d3372da9	1	/*
d3372da9	2	* Dolda Connect - Modular multiuser Direct Connect-style client
302a2600	3	* Copyright (C) 2004 Fredrik Tolf <fredrik@dolda2000.com>
d3372da9	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2 of the License, or
	8	* (at your option) any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to the Free Software
	17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	*/
b5010caa	19
b5010caa	20	#include <stdlib.h>
d3372da9	21	#include <langinfo.h>
	22	#include <stdio.h>
	23	#include <unistd.h>
d3372da9	24	#include <string.h>
	25	#include <sys/types.h>
	26	#include <errno.h>
	27	#include <wctype.h>
	28	#include <stddef.h>
	29	#include <wchar.h>
	30	#include <iconv.h>
	31	#include <arpa/inet.h>
05fe12f8	32	#include <gdbm.h>
d3372da9	33
	34	#ifdef HAVE_CONFIG_H
	35	#include <config.h>
	36	#endif
	37	#include "conf.h"
	38	#include "log.h"
	39	#include "utils.h"
	40
	41	static struct configmod *modules = NULL;
	42
	43	#if 0
	44	static void dumpconfig(void)
	45	{
	46	struct configmod *mod;
	47	struct configvar *var;
	48
	49	for(mod = modules; mod != NULL; mod = mod->next)
	50	{
	51	printf("%s:\n", mod->name);
	52	for(var = mod->vars; var->type != CONF_VAR_END; var++)
	53	{
	54	switch(var->type)
	55	{
	56	case CONF_VAR_BOOL:
	57	printf("\t%s: %s\n", var->name, var->val.num?"t":"f");
	58	break;
	59	case CONF_VAR_INT:
	60	printf("\t%s: %i\n", var->name, var->val.num);
	61	break;
	62	case CONF_VAR_STRING:
	63	printf("\t%s: \"%ls\" (%i)\n", var->name, var->val.str, wcslen(var->val.str));
	64	break;
	65	case CONF_VAR_IPV4:
	66	printf("\t%s: %s\n", var->name, inet_ntoa(var->val.ipv4));
	67	break;
	68	}
	69	}
	70	}
	71	}
	72	#endif
	73
	74	struct configvar confgetvar(char modname, char *varname)
	75	{
	76	struct configmod *m;
	77	struct configvar *v;
	78
	79	for(m = modules; m != NULL; m = m->next)
	80	{
	81	if(!strcmp(m->name, modname))
	82	{
	83	for(v = m->vars; v->type != CONF_VAR_END; v++)
	84	{
	85	if(!strcmp(v->name, varname))
	86	return(v);
	87	}
	88	break;
	89	}
	90	}
	91	return(NULL);
	92	}
	93
	94	void confregmod(struct configmod *mod)
	95	{
	96	struct configvar *var;
97
98	for(var = mod->vars; var->type != CONF_VAR_END; var++)
99	{
100	switch(var->type)
101	{
102	case CONF_VAR_BOOL:
103	case CONF_VAR_INT:
104	var->val.num = var->defaults.num;
105	break;
106	case CONF_VAR_STRING:
107	if(var->defaults.str != NULL)
108	{
109	var->val.str = swcsdup(var->defaults.str);
110	} else {
111	var->val.str = NULL;
112	}
113	break;
114	case CONF_VAR_IPV4:
115	var->val.ipv4.s_addr = var->defaults.ipv4.s_addr;
116	break;
117	}
118	CBCHAININIT(var, conf_update);
119	}
120	mod->next = modules;
121	modules = mod;
122	}
123
124	int runconfcmd(int argc, wchar_t **argv)
125	{
126	struct configmod *module;
127	struct configvar *var;
128	struct configcmd *cmd;
129	int ret, handled;
130	wchar_t *p;
131	char cmdn, buf, buf2, valbuf;
132	long num;
133	struct in_addr newipv4;
134	int cb;
135
136	if(argc < 1)
137	return(0);
138	if((cmdn = icwcstombs(argv[0], "us-ascii")) == NULL)
139	{
140	flog(LOG_WARNING, "could not convert %ls to us-ascii", argv[0]);
141	return(1);
142	}
143	ret = 1;
144	handled = 0;
145	if(!strcmp(cmdn, "set"))
146	{
147	handled = 1;
148	ret = 0;
149	if((p = wcschr(argv[1], L'.')) == NULL)
150	{
151	flog(LOG_WARNING, "illegal configuration variable format: %ls", argv[1]);
152	errno = EINVAL;
153	free(cmdn);
154	return(1);
155	}
156	*(p++) = L'\0';
157	if((buf = icwcstombs(argv[1], "us-ascii")) == NULL)
158	{
159	flog(LOG_WARNING, "could not convert %ls to us-ascii", argv[1]);
160	free(cmdn);
161	return(1);
162	}
163	if((buf2 = icwcstombs(p, "us-ascii")) == NULL)
164	{
165	free(buf);
166	flog(LOG_WARNING, "could not convert %ls to us-ascii", p);
167	free(cmdn);
168	return(1);
169	}
170	for(module = modules; module != NULL; module = module->next)
171	{
172	if(!strcmp(module->name, buf) && (module->vars != NULL))
173	{
174	for(var = module->vars; var->type != CONF_VAR_END; var++)
175	{
176	if(!strcmp(var->name, buf2))
177	{
178	cb = 0;
179	switch(var->type)
180	{
181	case CONF_VAR_BOOL:
182	wcstolower(argv[2]);
183	if(!wcscmp(argv[2], L"off") \|\|
184	!wcscmp(argv[2], L"false") \|\|
185	!wcscmp(argv[2], L"no") \|\|
186	!wcscmp(argv[2], L"0"))
187	{
188	if(var->val.num)
189	cb = 1;
190	var->val.num = 0;
191	} else if(!wcscmp(argv[2], L"on") \|\|
192	!wcscmp(argv[2], L"true") \|\|
193	!wcscmp(argv[2], L"yes") \|\|
194	!wcscmp(argv[2], L"1")) {
195	if(!var->val.num)
196	cb = 1;
197	var->val.num = 1;
198	} else {
199	flog(LOG_WARNING, "unrecognized boolean: %ls", argv[2]);
200	}
201	break;
202	case CONF_VAR_INT:
203	num = wcstol(argv[2], &p, 0);
204	if(p == argv[2])
205	{
206	flog(LOG_WARNING, "%ls: not a number, ignoring", argv[2]);
207	ret = 1;
208	} else {
209	if(*p != L'\0')
210	flog(LOG_WARNING, "%ls: could not entirely parse as a number, ignoring trailing garbage", argv[2]);
211	if(num != var->val.num)
212	cb = 1;
213	var->val.num = num;
214	}
215	break;
216	case CONF_VAR_STRING:
217	if(wcscmp(var->val.str, argv[2]))
218	cb = 1;
219	free(var->val.str);
220	var->val.str = swcsdup(argv[2]);
221	break;
222	case CONF_VAR_IPV4:
223	if((valbuf = icwcstombs(argv[2], "us-ascii")) == NULL)
224	{
225	flog(LOG_WARNING, "could not convert IPv4 address to as-ascii in var %s, ignoring", buf2);
226	} else {
227	if(!inet_aton(valbuf, &newipv4))
228	{
229	flog(LOG_WARNING, "could not parse IPv4 address (%s), ignoring", valbuf);
230	memcpy(&var->val.ipv4, &var->defaults.ipv4, sizeof(var->val.ipv4));
231	} else {
232	if(memcmp(&newipv4, &var->val.ipv4, sizeof(newipv4)))
233	cb = 1;
234	memcpy(&var->val.ipv4, &newipv4, sizeof(newipv4));
235	}
236	free(valbuf);
237	}
238	break;
239	}
240	if(cb)
241	CBCHAINDOCB(var, conf_update, var);
242	break;
243	}
244	}
245	if(var == NULL)
246	flog(LOG_WARNING, "variable %s not found, ignoring set command", buf2);
247	break;
248	}
249	}
250	if(module == NULL)
251	flog(LOG_WARNING, "module %s not found, ignoring set command", buf);
252	free(buf2);
253	free(buf);
254	}
255	for(module = modules; !handled && (module != NULL); module = module->next)
256	{
257	if(module->cmds != NULL)
258	{
259	for(cmd = module->cmds; cmd->name != NULL; cmd++)
260	{
261	if(!strcmp(cmd->name, cmdn))
262	{
263	handled = 1;
264	ret = cmd->handler(argc, argv);
265	break;
266	}
267	}
268	}
269	}
270	if(!handled)
271	flog(LOG_WARNING, "command not found: %s", cmdn);
272	free(cmdn);
273	return(ret);
274	}
275
d3372da9	276	void readconfig(FILE *stream)
	277	{
	278	int state;
	279	wint_t c;
	280	wchar_t *words[16];
	281	wchar_t buf, p, *p2;
	282	int w;
	283	int line;
	284
	285	buf = smalloc(sizeof(wchar_t) * 1024);
	286	state = 0;
	287	c = getwc(stream);
	288	w = 0;
	289	line = 1;
	290	p = buf;
	291	while(c != WEOF)
	292	{
	293	if(c == '#')
	294	{
	295	do
	296	c = getwc(stream);
	297	while((c != WEOF) && (c != L'\n'));
	298	continue;
	299	}
	300	switch(state)
	301	{
	302	case 0:
	303	if(iswspace(c))
	304	{
	305	if(c == L'\n')
	306	{
	307	line++;
	308	if(runconfcmd(w, words))
	309	flog(LOG_WARNING, "ignoring this command on line %i", line);
	310	w = 0;
	311	}
	312	c = getwc(stream);
	313	} else {
	314	state = 1;
	315	p2 = p;
	316	}
	317	break;
	318	case 1:
	319	if(c == L'\"')
	320	{
	321	state = 2;
	322	c = getwc(stream);
	323	} else if(iswspace(c)) {
	324	if(w >= 16)
	325	{
	326	flog(LOG_WARNING, "too many words on config line %i, ignoring rest", line);
	327	} else {
	328	*(p++) = L'\0';
	329	words[w++] = p2;
	330	}
	331	state = 0;
	332	} else {
	333	if(c == L'\\')
	334	c = getwc(stream);
	335	if(p - buf < 1023)
	336	*(p++) = c;
	337	else
	338	flog(LOG_WARNING, "too many characters on config line %i, ignoring rest", line);
	339	c = getwc(stream);
340	}
341	break;
342	case 2:
343	if(c == L'\"')
344	{
345	c = getwc(stream);
346	state = 1;
347	} else {
348	if(c == L'\\')
349	c = getwc(stream);
350	if(p - buf < 1023)
351	*(p++) = c;
352	else
353	flog(LOG_WARNING, "too many characters on config line %i, ignoring rest", line);
354	c = getwc(stream);
355	}
356	break;
357	}
358	}
359	free(buf);
360	if(ferror(stream))
361	flog(LOG_WARNING, "error on configuration stream: %s", strerror(errno));
362	if(state != 0)
363	flog(LOG_WARNING, "unexpected end of file");
364	}
05fe12f8	365
	366	/* {store,fetch}var re-opens the database every time, just in case two
	367	* doldacond processes would be running simultaneously. */
	368	void storevar(char key, void val, size_t len)
	369	{
	370	char *dbname;
	371	GDBM_FILE db;
	372	datum k, v;
	373
eb260dc7	374	dbname = findfile("dc-vardb", NULL, 1);
05fe12f8	375	if((db = gdbm_open(dbname, 0, GDBM_WRCREAT, 0666, NULL)) == NULL)
	376	{
	377	flog(LOG_CRIT, "could not open var database for writing, cannot continue: %s", gdbm_strerror(gdbm_errno));
	378	abort();
	379	}
	380	free(dbname);
	381	k.dptr = key;
	382	k.dsize = strlen(key);
	383	v.dptr = val;
	384	v.dsize = len;
	385	gdbm_store(db, k, v, GDBM_REPLACE);
	386	gdbm_close(db);
	387	}
	388
	389	void fetchvar(char key, size_t *lenb)
	390	{
	391	char *dbname;
	392	GDBM_FILE db;
	393	datum k, v;
	394
eb260dc7	395	if((dbname = findfile("dc-vardb", NULL, 0)) == NULL)
05fe12f8	396	return(NULL);
	397	if((db = gdbm_open(dbname, 0, GDBM_READER, 0666, NULL)) == NULL)
	398	return(NULL);
	399	free(dbname);
	400	k.dptr = key;
	401	k.dsize = strlen(key);
	402	v = gdbm_fetch(db, k);
	403	gdbm_close(db);
	404	if(v.dptr == NULL)
	405	return(NULL);
	406	if(lenb != NULL)
	407	*lenb = v.dsize;
	408	return(v.dptr);
	409	}