Context Navigation

source: branches/samba-3.0/source/ndpsmb/smbwrp.c

Visit:

Last change on this file was 129, checked in by Yuri Dario, 17 years ago
Strip also printer shares from server enumeration. ticket:58.
Property svn:eol-style set to `native`
File size: 44.0 KB

Rev	Line
[5]	1	#include "includes.h"
	2
	3	#include "smbwrp.h"
	4
[126]	5	#ifndef DEBUG_PRINTF
	6	#define debug_printf( ...)
	7	#endif
	8
[51]	9	static int
	10	net_share_enum_rpc(struct cli_state *cli,
	11	void (fn)(const char name,
	12	uint32 type,
	13	const char *comment,
	14	void *state),
	15	void *state)
	16	{
	17	int i;
	18	WERROR result;
	19	ENUM_HND enum_hnd;
	20	uint32 info_level = 1;
	21	uint32 preferred_len = 0xffffffff;
	22	uint32 type;
	23	SRV_SHARE_INFO_CTR ctr;
	24	fstring name = "";
	25	fstring comment = "";
	26	void *mem_ctx;
	27	struct rpc_pipe_client *pipe_hnd;
	28	NTSTATUS nt_status;
	29
	30	/* Open the server service pipe */
	31	pipe_hnd = cli_rpc_pipe_open_noauth(cli, PI_SRVSVC, &nt_status);
	32	if (!pipe_hnd) {
	33	DEBUG(1, ("net_share_enum_rpc pipe open fail!\n"));
	34	return -1;
	35	}
	36
	37	/* Allocate a context for parsing and for the entries in "ctr" */
	38	mem_ctx = talloc_init("libsmbclient: net_share_enum_rpc");
	39	if (mem_ctx == NULL) {
	40	DEBUG(0, ("out of memory for net_share_enum_rpc!\n"));
	41	cli_rpc_pipe_close(pipe_hnd);
	42	return -1;
	43	}
	44
	45	/* Issue the NetShareEnum RPC call and retrieve the response */
	46	init_enum_hnd(&enum_hnd, 0);
	47	result = rpccli_srvsvc_net_share_enum(pipe_hnd,
	48	mem_ctx,
	49	info_level,
	50	&ctr,
	51	preferred_len,
	52	&enum_hnd);
	53
	54	/* Was it successful? */
	55	if (!W_ERROR_IS_OK(result) \|\| ctr.num_entries == 0) {
	56	/* Nope. Go clean up. */
	57	goto done;
	58	}
	59
	60	/* For each returned entry... */
	61	for (i = 0; i < ctr.num_entries; i++) {
	62
	63	/* pull out the share name */
	64	rpcstr_pull_unistr2_fstring(
	65	name, &ctr.share.info1[i].info_1_str.uni_netname);
	66
	67	/* pull out the share's comment */
	68	rpcstr_pull_unistr2_fstring(
	69	comment, &ctr.share.info1[i].info_1_str.uni_remark);
	70
	71	/* Get the type value */
	72	type = ctr.share.info1[i].info_1.type;
	73
	74	/* Add this share to the list */
	75	(*fn)(name, type, comment, state);
	76	}
	77
	78	done:
	79	/* Close the server service pipe */
	80	cli_rpc_pipe_close(pipe_hnd);
	81
	82	/* Free all memory which was allocated for this request */
	83	TALLOC_FREE(mem_ctx);
	84
	85	/* Tell 'em if it worked */
	86	return W_ERROR_IS_OK(result) ? 0 : -1;
	87	}
	88
[5]	89	/*
	90	* Wrapper for cli_errno to return not connected error on negative fd
	91	*/
	92	int os2cli_errno(cli_state * cli)
	93	{
	94	if (cli->fd == -1)
	95	{
	96	return ENOTCONN;
	97	}
	98	return cli_errno(cli);
	99	}
	100
	101	int _System smbwrp_getclisize(void)
	102	{
	103	return sizeof(struct cli_state);
	104	}
	105
	106	/*****************************************************
	107	initialise structures
	108	*******************************************************/
	109	int _System smbwrp_init(void)
	110	{
	111	static int initialised = 0;
	112	char *p;
	113	pstring line;
	114
	115	if (initialised)
	116	{
	117	return 0;
	118	}
	119	initialised = 1;
	120
[6]	121	load_case_tables();
[5]	122
[6]	123	init_globals( True);
	124
[5]	125	load_interfaces();
	126
	127	if (!init_names())
	128	{
	129	return 1;
	130	}
	131
	132	/*
	133	if ((p=smbw_getshared("RESOLVE_ORDER"))) {
	134	lp_set_name_resolve_order(p);
	135	}
	136	*/
	137	return 0;
	138
	139	}
	140
	141	#if 0
	142	/*****************************************************
	143	remove redundent stuff from a filename
	144	*******************************************************/
	145	void clean_fname(char *name)
	146	{
	147	char p, p2;
	148	int l;
	149	int modified = 1;
	150
	151	if (!name) return;
	152
	153	while (modified) {
	154	modified = 0;
	155
	156	if ((p=strstr(name,"/./"))) {
	157	modified = 1;
	158	while (*p) {
	159	p[0] = p[2];
	160	p++;
	161	}
	162	}
	163
	164	if ((p=strstr(name,"//"))) {
	165	modified = 1;
	166	while (*p) {
	167	p[0] = p[1];
	168	p++;
	169	}
	170	}
	171
	172	if (strcmp(name,"/../")==0) {
	173	modified = 1;
	174	name[1] = 0;
	175	}
	176
	177	if ((p=strstr(name,"/../"))) {
	178	modified = 1;
	179	for (p2=(p>name?p-1:p);p2>name;p2--) {
	180	if (p2[0] == '/') break;
	181	}
	182	while (*p2) {
	183	p2[0] = p2[3];
	184	p2++;
	185	}
	186	}
	187
	188	if (strcmp(name,"/..")==0) {
	189	modified = 1;
	190	name[1] = 0;
	191	}
	192
	193	l = strlen(name);
	194	p = l>=3?(name+l-3):name;
	195	if (strcmp(p,"/..")==0) {
	196	modified = 1;
	197	for (p2=p-1;p2>name;p2--) {
	198	if (p2[0] == '/') break;
	199	}
	200	if (p2==name) {
	201	p[0] = '/';
	202	p[1] = 0;
	203	} else {
	204	p2[0] = 0;
	205	}
	206	}
	207
	208	l = strlen(name);
	209	p = l>=2?(name+l-2):name;
	210	if (strcmp(p,"/.")==0) {
	211	if (p == name) {
	212	p[1] = 0;
	213	} else {
	214	p[0] = 0;
	215	}
	216	}
	217
	218	if (strncmp(p=name,"./",2) == 0) {
	219	modified = 1;
	220	do {
	221	p[0] = p[2];
	222	} while (*p++);
	223	}
	224
	225	l = strlen(p=name);
	226	if (l > 1 && p[l-1] == '/') {
	227	modified = 1;
	228	p[l-1] = 0;
	229	}
	230	}
	231	}
	232	#endif
	233
	234
	235	/****************************************************************************
	236	send a qpathinfo call with the SMB_QUERY_FILE_ALL_INFO info level
	237	****************************************************************************/
	238	BOOL cli_qpathinfo3(struct cli_state cli, const char fname,
	239	time_t c_time, time_t a_time, time_t *m_time,
	240	time_t w_time, off_t size, uint16 *mode,
	241	SMB_INO_T *ino)
	242	{
	243	unsigned int data_len = 0;
	244	unsigned int param_len = 0;
	245	uint16 setup = TRANSACT2_QPATHINFO;
	246	pstring param;
	247	char rparam=NULL, rdata=NULL;
	248	char *p;
	249
	250	p = param;
	251	memset(p, 0, 6);
	252	SSVAL(p, 0, SMB_QUERY_FILE_ALL_INFO);
	253	p += 6;
	254	p += clistr_push(cli, p, fname, sizeof(pstring)-6, STR_TERMINATE);
	255
	256	param_len = PTR_DIFF(p, param);
	257
	258	if (!cli_send_trans(cli, SMBtrans2,
	259	NULL, /* name */
	260	-1, 0, /* fid, flags */
	261	&setup, 1, 0, /* setup, length, max */
	262	param, param_len, 10, /* param, length, max */
	263	NULL, data_len, cli->max_xmit /* data, length, max */
	264	)) {
	265	return False;
	266	}
	267
	268	if (!cli_receive_trans(cli, SMBtrans2,
	269	&rparam, &param_len,
	270	&rdata, &data_len)) {
	271	return False;
	272	}
	273
	274	if (!rdata \|\| data_len < 22) {
	275	return False;
	276	}
	277
	278	if (c_time) {
[126]	279	*c_time = convert_timespec_to_time_t(interpret_long_date(rdata+0));
[5]	280	}
	281	if (a_time) {
[126]	282	*a_time = convert_timespec_to_time_t(interpret_long_date(rdata+8));
[5]	283	}
	284	if (m_time) {
[126]	285	*m_time = convert_timespec_to_time_t(interpret_long_date(rdata+16));
[5]	286	}
	287	if (w_time) {
[126]	288	*w_time = convert_timespec_to_time_t(interpret_long_date(rdata+24));
[5]	289	}
	290	if (mode) {
	291	*mode = SVAL(rdata, 32);
	292	}
	293	if (size) {
	294	*size = IVAL2_TO_SMB_BIG_UINT(rdata, 48);
	295	}
	296	if (ino) {
	297	*ino = IVAL(rdata, 64);
	298	}
	299
	300	SAFE_FREE(rdata);
	301	SAFE_FREE(rparam);
	302	return True;
	303	}
	304
	305	/****************************************************************************
	306	send a qfileinfo call
	307	****************************************************************************/
	308	BOOL cli_qfileinfo3(struct cli_state *cli, int fnum,
	309	uint16 mode, off_t size,
	310	time_t c_time, time_t a_time, time_t *m_time,
	311	time_t w_time, SMB_INO_T ino)
	312	{
	313	unsigned int data_len = 0;
	314	unsigned int param_len = 0;
	315	uint16 setup = TRANSACT2_QFILEINFO;
	316	pstring param;
	317	char rparam=NULL, rdata=NULL;
	318
	319	/* if its a win95 server then fail this - win95 totally screws it
	320	up */
	321	if (cli->win95) return False;
	322
	323	param_len = 4;
	324
	325	memset(param, 0, param_len);
	326	SSVAL(param, 0, fnum);
	327	SSVAL(param, 2, SMB_QUERY_FILE_ALL_INFO);
	328
	329	if (!cli_send_trans(cli, SMBtrans2,
	330	NULL, /* name */
	331	-1, 0, /* fid, flags */
	332	&setup, 1, 0, /* setup, length, max */
	333	param, param_len, 2, /* param, length, max */
	334	NULL, data_len, cli->max_xmit /* data, length, max */
	335	)) {
	336	return False;
	337	}
	338
	339	if (!cli_receive_trans(cli, SMBtrans2,
	340	&rparam, &param_len,
	341	&rdata, &data_len)) {
	342	return False;
	343	}
	344
	345	if (!rdata \|\| data_len < 68) {
	346	return False;
	347	}
	348
	349	if (c_time) {
[126]	350	*c_time = convert_timespec_to_time_t(interpret_long_date(rdata+0));
[5]	351	}
	352	if (a_time) {
[126]	353	*a_time = convert_timespec_to_time_t(interpret_long_date(rdata+8));
[5]	354	}
	355	if (m_time) {
[126]	356	*m_time = convert_timespec_to_time_t(interpret_long_date(rdata+16));
[5]	357	}
	358	if (w_time) {
[126]	359	*w_time = convert_timespec_to_time_t(interpret_long_date(rdata+24));
[5]	360	}
	361	if (mode) {
	362	*mode = SVAL(rdata, 32);
	363	}
	364	if (size) {
	365	*size = IVAL2_TO_SMB_BIG_UINT(rdata, 48);
	366	}
	367	if (ino) {
	368	*ino = IVAL(rdata, 64);
	369	}
	370
	371	SAFE_FREE(rdata);
	372	SAFE_FREE(rparam);
	373	return True;
	374	}
	375
	376	/*****************************************************
	377	return a connection to a server
	378	*******************************************************/
[107]	379	int _System smbwrp_connect(smbwrp_server * srv, struct cli_state ** cli, int krb5support)
[5]	380	{
	381	char * server = srv->server_name;
	382	char * share = *(srv->share_name) ? srv->share_name : "IPC$";
	383	char * workgroup = srv->workgroup;
	384	struct nmb_name called, calling;
	385	char p, server_n = server;
	386	fstring group;
	387	struct in_addr ip;
[6]	388	NTSTATUS rc;
	389	struct cli_state * c;
[128]	390	char* dev_type;
[5]	391
[6]	392	zero_ip(&ip);
[5]	393
[112]	394	debuglocal(1,"Connecting to \\\\%s:*********@%s:%s\\%s. Master %s:%d\n", srv->username, workgroup, server, share, srv->master, srv->ifmastergroup);
[5]	395
	396	if (!*server) {
	397	struct in_addr sip;
	398
	399	if (*workgroup)
	400	{
	401	if (!find_master_ip(workgroup, &sip)) {
	402	return 1;
	403	}
	404	fstrcpy(group, inet_ntoa(sip));
	405	server_n = group;
	406	} else
	407	if (*srv->master)
	408	{
	409	if (srv->ifmastergroup)
	410	{
	411	if (!find_master_ip(srv->master, &sip)) {
	412	return 11;
	413	}
	414	strncpy(srv->master, inet_ntoa(sip), sizeof(srv->master) - 1);
	415	srv->ifmastergroup = 0;
	416	}
	417	server_n = srv->master;
	418	} else
	419	{
	420	return 10;
	421	}
	422	}
	423
	424	make_nmb_name(&calling, global_myname(), 0x0);
	425	// make_nmb_name(&calling, "WORK", 0x0); // this machine name
	426	make_nmb_name(&called , server_n, 0x20);
	427
	428	again:
	429	zero_ip(&ip);
	430
	431	/* have to open a new connection */
[6]	432	if (!(c=cli_initialise()))
[5]	433	{
	434	return 2;
	435	}
	436
[64]	437	if (!NT_STATUS_IS_OK(cli_connect(c, server_n, &ip)))
[5]	438	{
	439	return 3;
	440	}
[107]	441
	442	if (krb5support == 1){
	443	debuglocal(1,"Kerberos support enabled\n");
	444	c->use_kerberos = True;}
	445
[5]	446	if (!cli_session_request(c, &calling, &called)) {
	447	cli_shutdown(c);
	448	if (strcmp(called.name, "*SMBSERVER")) {
	449	make_nmb_name(&called , "*SMBSERVER", 0x20);
	450	goto again;
	451	}
	452	return 4;
	453	}
	454
[24]	455	debuglocal(4," session request ok\n");
[5]	456
	457	if (!cli_negprot(c)) {
	458	cli_shutdown(c);
	459	return 5;
	460	}
	461
[112]	462	debuglocal(4," session setuping for <%s>/<********> in <%s> %08x %08x %08x\n", srv->username, workgroup, c->protocol, c->sec_mode, c->capabilities);
[5]	463
[6]	464	if (!NT_STATUS_IS_OK(cli_session_setup(c, srv->username,
[5]	465	srv->password, strlen(srv->password),
	466	srv->password, strlen(srv->password),
[6]	467	workgroup))) {
[112]	468	debuglocal(4,"%s/******** login failed\n", srv->username);
[5]	469	/* try an anonymous login if it failed */
[6]	470	if (!NT_STATUS_IS_OK(cli_session_setup(c, "", "", 1,"", 0, workgroup))) {
[24]	471	debuglocal(4,"Anonymous login failed");
[5]	472	cli_shutdown(c);
	473	return 6;
	474	}
	475	}
	476
[112]	477	debuglocal(4," session setup ok. Sending tconx <%s> <********>\n", share);
[5]	478
[128]	479	// YD ticket:58 we need to check resource type to avoid connecting to printers.
	480	// dev type is set to IPC for IPC$, A: for everything else (printers use LPT1:)
	481	if (!strcmp( share, "IPC$"))
	482	dev_type = "IPC";
	483	else
	484	dev_type = "A:";
	485
	486	if (!cli_send_tconX(c, share, dev_type,
[5]	487	srv->password, strlen(srv->password)+1)) {
	488	cli_shutdown(c);
	489	return 7;
	490	}
	491
[24]	492	debuglocal(4," tconx ok. cli caps %08x\n", c->capabilities);
[5]	493
[6]	494	// copy back cli_state
[69]	495	*cli = c;
[6]	496
[5]	497	// srv->dev = (dev_t)(str_checksum(server) ^ str_checksum(share));
	498
	499	return 0;
	500	}
	501
	502	/*****************************************************
	503	close a connection to a server
	504	*******************************************************/
[69]	505	void _System smbwrp_disconnect(struct cli_state ** cli)
[5]	506	{
	507	if (cli)
	508	{
[69]	509	// this call will free all buffers, close handles and free cli mem
	510	cli_shutdown(*cli);
	511	// set to zero because no longer valid
	512	*cli = 0;
[5]	513	}
	514	}
	515
	516
	517
	518	/*****************************************************
	519	a wrapper for open()
	520	*******************************************************/
	521	int _System smbwrp_open(cli_state * cli, smbwrp_file * file)
	522	{
	523	int fd = -1;
	524
	525	if (!cli \|\| !file \|\| !*file->fname)
	526	{
	527	return EINVAL;
	528	}
	529	if (file->denymode < DENY_ALL \|\| file->denymode > DENY_NONE)
	530	{
	531	file->denymode = DENY_NONE;
	532	}
	533
[24]	534	debuglocal(4,"cli_open(%s) attr %08x mode %02x denymode %02x\n", file->fname, file->openattr, file->openmode, file->denymode);
[5]	535	file->fd = cli_open(cli, file->fname, file->openmode, file->denymode);
	536	if (file->fd == -1)
	537	{
	538	return os2cli_errno(cli);
	539	}
	540	if (file->openmode & (O_WRONLY \| O_RDWR \| O_TRUNC \| O_CREAT))
	541	{
	542	time_t t;
	543	file->mtime = time(NULL);
[6]	544	t = get_time_zone(file->mtime);
[24]	545	debuglocal(4,"cli_open mtime %lu %lu\n", file->mtime, t);
[5]	546	file->mtime -= t;
	547	}
	548	file->offset = 0;
	549	return 0;
	550	}
	551
	552	/*****************************************************
	553	a wrapper for read()
	554	*******************************************************/
	555	int _System smbwrp_read(cli_state * cli, smbwrp_file * file, void buf, unsigned long count, unsigned long result)
	556	{
	557	int ret;
	558
	559	if (!cli \|\| !file \|\| !buf \|\| !result)
	560	{
	561	return EINVAL;
	562	}
	563
	564	*result = 0;
	565	ret = cli_read(cli, file->fd, buf, file->offset, count);
	566	if (ret == -1)
	567	{
	568	return os2cli_errno(cli);
	569	}
	570
	571	file->offset += ret;
	572	*result = ret;
	573	return 0;
	574	}
	575
	576
	577
	578	/*****************************************************
	579	a wrapper for write()
	580	*******************************************************/
	581	int _System smbwrp_write(cli_state * cli, smbwrp_file * file, void buf, unsigned long count, unsigned long result)
	582	{
	583	int ret;
	584
	585	if (!cli \|\| !file \|\| !buf \|\| !result)
	586	{
	587	return EINVAL;
	588	}
	589
	590	*result = 0;
[24]	591	//debuglocal(1,("Write %x %d %lld %d", cli, file->fd, file->offset, count));
[5]	592	ret = cli_write(cli, file->fd, 0, buf, file->offset, count);
	593	if (ret == -1)
	594	{
	595	return os2cli_errno(cli);
	596	}
	597
	598	file->offset += ret;
	599	*result = ret;
	600	return 0;
	601	}
	602
	603	/*****************************************************
	604	a wrapper for close()
	605	*******************************************************/
	606	int _System smbwrp_close(cli_state * cli, smbwrp_file * file)
	607	{
	608	int rc = 0;
	609	if (!cli \|\| !file)
	610	{
	611	return EINVAL;
	612	}
	613
	614
	615	if (!cli_close(cli, file->fd))
	616	{
	617	return os2cli_errno(cli);
	618	}
	619	file->fd = -1;
	620	file->offset = 0;
	621	if (file->openattr \|\| file->mtime)
	622	{
[126]	623	debuglocal(4,"Set attr on close %s %08x %d %d\n", file->fname, file->openattr, file->mtime, file->mtime);
	624	if (!cli_setatr(cli, file->fname, file->openattr, file->mtime))
[5]	625	{
[24]	626	debuglocal(4,"Set attr on close failed %d\n", os2cli_errno(cli));
[5]	627	//rc = os2cli_errno(cli);
	628	}
	629	file->openattr = 0;
	630	file->mtime = 0;
	631	}
	632	*file->fname = 0;
	633	return rc;
	634	}
	635
	636	/*****************************************************
	637	a wrapper for setfilesize()
	638	*******************************************************/
	639	int cli_setfilenewsize(struct cli_state *cli, int fnum, off_t newsize)
	640	{
	641	unsigned int data_len = 8;
	642	unsigned int param_len = 6;
	643	uint16 setup = TRANSACT2_SETFILEINFO;
	644	pstring param;
	645	char rparam=NULL, rdata=NULL;
	646
	647	memset(param, 0, param_len);
	648	SSVAL(param,0,fnum);
	649	SSVAL(param,2,SMB_SET_FILE_END_OF_FILE_INFO);
	650
	651	if (!cli_send_trans(cli, SMBtrans2,
	652	NULL, /* name */
	653	-1, 0, /* fid, flags */
	654	&setup, 1, 0, /* setup, length, max */
	655	param, param_len, 2, /* param, length, max */
	656	(char )&newsize, sizeof(newsize), cli->max_xmit / data, length, max */
	657	)) {
	658	return False;
	659	}
	660
	661	if (!cli_receive_trans(cli, SMBtrans2,
	662	&rparam, &param_len,
	663	&rdata, &data_len)) {
	664	return False;
	665	}
	666
	667	SAFE_FREE(rdata);
	668	SAFE_FREE(rparam);
	669
	670	return True;
	671	}
	672
	673	int _System smbwrp_setfilesize(cli_state * cli, smbwrp_file * file, long long newsize)
	674	{
	675	int rc = 0;
	676	if (!cli \|\| !file)
	677	{
	678	return EINVAL;
	679	}
	680
[24]	681	debuglocal(4,"cli_setnewfileszie(%s) %lld\n", file->fname, newsize);
[5]	682	if (!cli_setfilenewsize(cli, file->fd, newsize))
	683	{
	684	if (newsize)
	685	{
	686	rc = os2cli_errno(cli);
	687	}
	688
	689	if (!cli_close(cli, file->fd))
	690	{
	691	return os2cli_errno(cli);
	692	}
	693	file->fd = -1;
	694	file->offset = 0;
	695	file->openmode &= ~(O_CREAT \| O_EXCL);
	696	file->openmode \|= O_TRUNC;
[24]	697	debuglocal(4,"cli_setnewfileszie : cli_open(%s) attr %08x mode %02x denymode %02x\n", file->fname, file->openattr, file->openmode, file->denymode);
[5]	698	file->fd = cli_open(cli, file->fname, file->openmode, file->denymode);
	699	if (file->fd == -1)
	700	{
	701	return os2cli_errno(cli);
	702	}
	703	}
	704	return 0;
	705	}
	706
	707	/*****************************************************
	708	a wrapper for rename()
	709	*******************************************************/
	710	int _System smbwrp_rename(cli_state * cli, char oldname, char newname)
	711	{
	712	if (!cli \|\| !oldname \|\| !newname)
	713	{
	714	return EINVAL;
	715	}
	716
[24]	717	debuglocal(1,"Rename <%s> -> <%s>\n", oldname, newname);
[5]	718	//cli_unlink(cli, newname);
	719	// if (!cli_rename(cli, oldname, newname) && !cli_ntrename(cli, oldname, newname))
	720	if (!cli_rename(cli, oldname, newname))
	721	{
	722	return os2cli_errno(cli);
	723	}
	724	return 0;
	725	}
	726
	727
	728	/*****************************************************
	729	a wrapper for chmod()
	730	*******************************************************/
	731	int _System smbwrp_setattr(cli_state * cli, smbwrp_fileinfo *finfo)
	732	{
	733	if (!cli \|\| !finfo \|\| !*finfo->fname)
	734	{
	735	return EINVAL;
	736	}
	737
[24]	738	debuglocal(4,"Setting on <%s> attr %04x, time %lu/%lu\n", finfo->fname, finfo->attr, finfo->mtime, finfo->mtime + get_time_zone(finfo->mtime));
[6]	739	if (!cli_setatr(cli, finfo->fname, finfo->attr, finfo->mtime + (finfo->mtime == 0 ? 0 : get_time_zone(finfo->mtime)))
[5]	740	&& !cli_setatr(cli, finfo->fname, finfo->attr, 0))
	741	{
	742	return os2cli_errno(cli);
	743	}
	744	return 0;
	745	}
	746
	747	/*****************************************************
	748	a wrapper for unlink()
	749	*******************************************************/
	750	int _System smbwrp_unlink(cli_state * cli, const char *fname)
	751	{
	752	if (!cli \|\| !fname)
	753	{
	754	return EINVAL;
	755	}
	756	#if 0
	757	if (strncmp(cli->dev, "LPT", 3) == 0)
	758	{
	759	int job = smbw_stat_printjob(cli, fname, NULL, NULL);
	760	if (job == -1)
	761	{
	762	goto failed;
	763	}
	764	if (cli_printjob_del(cli, job) != 0)
	765	{
	766	goto failed;
	767	}
	768	} else
	769	#endif
	770	if (!cli_unlink(cli, fname))
	771	{
	772	return os2cli_errno(cli);
	773	}
	774	return 0;
	775	}
	776
	777	/*****************************************************
	778	a wrapper for lseek()
	779	*******************************************************/
	780	int _System smbwrp_lseek(cli_state * cli, smbwrp_file * file, int whence, long long offset)
	781	{
	782	off_t size;
	783	if (!cli \|\| !file)
	784	{
	785	return EINVAL;
	786	}
	787
[24]	788	debuglocal(4,"lseek %d %lld %lld\n", whence, offset, file->offset);
[5]	789
	790	switch (whence) {
	791	case SEEK_SET:
	792	if (offset < 0)
	793	{
	794	return EINVAL;
	795	}
	796	file->offset = offset;
	797	break;
	798	case SEEK_CUR:
	799	file->offset += offset;
	800	break;
	801	case SEEK_END:
	802	if (offset > 0)
	803	{
	804	return EINVAL;
	805	}
	806	if (!cli_qfileinfo3(cli, file->fd,
	807	NULL, &size, NULL, NULL, NULL,
	808	NULL, NULL) &&
	809	!cli_getattrE(cli, file->fd,
	810	NULL, (SMB_BIG_UINT *)&size, NULL, NULL, NULL))
	811	{
	812	return os2cli_errno(cli);
	813	}
	814	file->offset = size + offset;
	815	break;
	816	default: return EINVAL;
	817	}
	818
	819	return 0;
	820	}
	821
	822	/*****************************************************
	823	try to do a QPATHINFO and if that fails then do a getatr
	824	this is needed because win95 sometimes refuses the qpathinfo
	825	*******************************************************/
[75]	826	int _System smbwrp_getattr(smbwrp_server srv, cli_state cli, smbwrp_fileinfo *finfo)
[5]	827	{
	828	SMB_INO_T ino = 0;
	829	if (!cli \|\| !finfo \|\| !*finfo->fname)
	830	{
	831	return EINVAL;
	832	}
[126]	833	debug_printf( "smbwrp_getattr\n");
[24]	834	debuglocal(4,"getattr %d %d <%s>\n", cli->capabilities & CAP_NOPATHINFO2, cli->capabilities & CAP_NT_SMBS, finfo->fname);
[5]	835	if (!(cli->capabilities & CAP_NOPATHINFO2) &&
	836	cli_qpathinfo3(cli, finfo->fname, (time_t )&finfo->ctime, (time_t )&finfo->atime, (time_t *)&finfo->mtime, NULL,
	837	(off_t )&finfo->size, (unsigned short )&finfo->attr, &ino))
	838	{
	839	finfo->attr &= 0x7F;
[24]	840	//debuglocal(2,("gotattr %08x <%s>\n", finfo->attr, finfo->fname));
[6]	841	// finfo->ctime -= get_time_zone(finfo->ctime);
	842	// finfo->atime -= get_time_zone(finfo->atime);
	843	// finfo->mtime -= get_time_zone(finfo->mtime);
[5]	844	return 0;
	845	}
[24]	846	//debuglocal(2,("getattr rc1 %d\n", os2cli_errno(cli)));
[5]	847
[75]	848	/* If the path is not on a share (it is a workgroup or a server),
	849	* then cli_qpathinfo3 obviously fails. Return some fake information
	850	* about the directory.
	851	*/
	852	if ( *srv->server_name == 0
	853	\|\| (strcmp(cli->dev,"IPC") == 0)
	854	\|\| *srv->share_name == 0
	855	\|\| (stricmp(srv->share_name,"IPC$") == 0)
	856	\|\| (strncmp(cli->dev,"LPT",3) == 0)
	857	)
	858	{
	859	debuglocal(4,"getattr not a share.\n");
	860	(time_t )&finfo->ctime = time (NULL);
	861	(time_t )&finfo->atime = time (NULL);
	862	(time_t )&finfo->mtime = time (NULL);
	863	finfo->size = 0;
	864	finfo->easize = 0;
	865	finfo->attr = aDIR;
	866	return 0;
	867	}
	868
[5]	869	/* if this is NT then don't bother with the getatr */
	870	if (cli->capabilities & CAP_NT_SMBS && !(cli->capabilities & CAP_NOPATHINFO2))
	871	{
	872	int rc = os2cli_errno(cli);
	873	// cli_qpathinfo* reports EINVAL when path of given file not exists
	874	// thus there is no real situation when EINVAL should be returned to
	875	// client at this point, we just replace it to ENOTDIR
	876	if (rc == EINVAL)
	877	{
	878	rc = ENOTDIR;
	879	}
	880	return rc;
	881	}
	882
[126]	883	if (cli_getatr(cli, finfo->fname, (unsigned short )&finfo->attr, &finfo->size, (time_t )&finfo->mtime))
[5]	884	{
[24]	885	//debuglocal(2,("gotattr1 %08x <%s>\n", finfo->attr, finfo->fname));
[6]	886	finfo->mtime -= get_time_zone(finfo->mtime);
[49]	887	finfo->atime = finfo->atime; //was mtime
	888	finfo->ctime = finfo->ctime; //was mtime
[5]	889	cli->capabilities &= CAP_NOPATHINFO2;
	890	return 0;
	891	}
	892	return os2cli_errno(cli);
	893	}
	894
	895	/*****************************************************
	896	try to do a QPATHINFO and if that fails then do a getatr
	897	this is needed because win95 sometimes refuses the qpathinfo
	898	*******************************************************/
	899	int _System smbwrp_fgetattr(cli_state * cli, smbwrp_file file, smbwrp_fileinfo finfo)
	900	{
	901	SMB_INO_T ino = 0;
	902	if (!cli \|\| !file \|\| !finfo)
	903	{
	904	return EINVAL;
	905	}
	906
	907	strncpy(finfo->fname, file->fname, sizeof(finfo->fname) - 1);
	908	if (!cli_qfileinfo3(cli, file->fd,
	909	(unsigned short )&finfo->attr, (off_t )&finfo->size, (time_t )&finfo->ctime, (time_t )&finfo->atime, (time_t *)&finfo->mtime, NULL,
	910	&ino))
	911	{
	912	if (!cli_getattrE(cli, file->fd,
	913	(unsigned short )&finfo->attr, (SMB_BIG_UINT )(&finfo->size), (time_t )&finfo->ctime, (time_t )&finfo->atime, (time_t *)&finfo->mtime))
	914	{
	915	return os2cli_errno(cli);
	916	}
	917	else
	918	{
[6]	919	finfo->ctime -= get_time_zone(finfo->ctime);
	920	finfo->atime -= get_time_zone(finfo->atime);
	921	finfo->mtime -= get_time_zone(finfo->mtime);
[5]	922	}
	923	}
	924	else
	925	{
[6]	926	// finfo->ctime -= get_time_zone(finfo->ctime);
	927	// finfo->atime -= get_time_zone(finfo->atime);
	928	// finfo->mtime -= get_time_zone(finfo->mtime);
[5]	929	}
	930
	931	return 0;
	932	}
	933
	934	// =============================DIRECTORY ROUTINES============================
	935
	936	/*****************************************************
	937	add a entry to a directory listing
	938	*******************************************************/
[6]	939	static void smbwrp_dir_add(const char* mnt, smbwrp_fileinfo finfo, const char mask, void *state)
[5]	940	{
	941	if (state && finfo)
	942	{
	943	filelist_state * st = (filelist_state *)state;
	944	if (st->add_dir_entry)
	945	{
[24]	946	debuglocal(8,"adding <%s> %d %d\n", finfo->fname, sizeof(st->finfo), st->datalen);
[5]	947	memcpy(&st->finfo, finfo, sizeof(st->finfo));
	948	st->add_dir_entry(state);
	949	}
	950	}
	951	}
[42]	952
[6]	953	#if 0
[5]	954	static void smbwrp_dir_add_old(struct file_info finfo, const char mask, void *state)
	955	{
	956	if (state && finfo)
	957	{
	958	filelist_state * st = (filelist_state *)state;
	959	if (st->add_dir_entry)
	960	{
	961	strncpy(st->finfo.fname, finfo->name, sizeof(st->finfo.fname) - 1);
	962	st->finfo.size = finfo->size;
	963	st->finfo.easize = -1;
	964	st->finfo.attr = finfo->mode;
[6]	965	st->finfo.ctime = finfo->ctime_ts.tv_sec - get_time_zone(finfo->ctime_ts.tv_sec);
	966	st->finfo.mtime = finfo->mtime_ts.tv_sec - get_time_zone(finfo->mtime_ts.tv_sec);
	967	st->finfo.atime = finfo->atime_ts.tv_sec - get_time_zone(finfo->atime_ts.tv_sec);
[5]	968	st->add_dir_entry(state);
	969	}
	970	}
	971	}
[6]	972	#endif
[5]	973
[6]	974	static void smbwrp_special_add(const char * name, void * state)
[5]	975	{
	976	smbwrp_fileinfo finfo = {0};
	977
	978	if (!name)
	979	{
	980	return;
	981	}
	982
	983	ZERO_STRUCT(finfo);
	984
	985	strncpy(finfo.fname, name, sizeof(finfo.fname) - 1);
	986	finfo.attr = aRONLY \| aDIR;
	987
[6]	988	smbwrp_dir_add("", &finfo, NULL, state);
[5]	989	}
	990
	991	static void smbwrp_printjob_add(struct print_job_info job, void state)
	992	{
	993	smbwrp_fileinfo finfo = {0};
	994
	995	ZERO_STRUCT(finfo);
	996
	997	//printf("Printjob <%s>\n", job->name);
	998
	999	strncpy(finfo.fname, job->name, sizeof(finfo.fname) - 1);
[6]	1000	finfo.mtime = job->t - get_time_zone(job->t);
[49]	1001	finfo.atime = finfo.atime; //was mtime
	1002	finfo.ctime = finfo.ctime; //was mtime
[5]	1003	finfo.attr = aRONLY;
	1004	finfo.size = job->size;
	1005
[6]	1006	smbwrp_dir_add("", &finfo, NULL, state);
[5]	1007	}
	1008
	1009	static void smbwrp_share_add(const char *share, uint32 type,
	1010	const char comment, void state)
	1011	{
	1012	smbwrp_fileinfo finfo = {0};
	1013
[129]	1014	// strip administrative names and printers from list
	1015	if (type == STYPE_PRINTQ \|\| strcmp(share,"IPC$") == 0) return;
[5]	1016
	1017	ZERO_STRUCT(finfo);
	1018
	1019	strncpy(finfo.fname, share, sizeof(finfo.fname) - 1);
	1020	finfo.attr = aRONLY \| aDIR;
	1021
[6]	1022	smbwrp_dir_add("", &finfo, NULL, state);
[5]	1023	}
	1024
	1025	/****************************************************************************
	1026	Interpret a long filename structure - this is mostly guesses at the moment.
	1027	The length of the structure is returned
	1028	The structure of a long filename depends on the info level. 260 is used
	1029	by NT and 2 is used by OS/2
	1030	****************************************************************************/
[6]	1031	// YD from libsmb\clilist.c
	1032	static size_t _os2_interpret_long_filename(struct cli_state *cli,
	1033	int level,char p, smbwrp_fileinfo finfo,
	1034	uint32 p_resume_key, DATA_BLOB p_last_name_raw, uint32 *p_last_name_raw_len)
[5]	1035	{
	1036	extern file_info def_finfo;
	1037	int len;
	1038	char *base = p;
	1039	smbwrp_fileinfo finfo1;
	1040
	1041	if (!finfo) finfo = &finfo1;
	1042
[113]	1043	if (p_resume_key) {
	1044	*p_resume_key = 0;
	1045	}
	1046
[5]	1047	finfo->attr = def_finfo.mode;
[6]	1048	finfo->mtime = def_finfo.mtime_ts.tv_sec;
	1049	finfo->atime = def_finfo.atime_ts.tv_sec;
	1050	finfo->ctime = def_finfo.ctime_ts.tv_sec;
[5]	1051	strncpy(finfo->fname, def_finfo.name, sizeof(finfo->fname) - 1);
[126]	1052	debug_printf( "fname %s (serverzone %d, level %d)\n",finfo->fname, cli->serverzone, level);
	1053
[5]	1054	switch (level) {
	1055	case 1: /* OS/2 understands this */
	1056	/* these dates are converted to GMT by
	1057	make_unix_date */
[42]	1058	finfo->ctime = cli_make_unix_date2(cli, p+4) - cli->serverzone;
	1059	finfo->atime = cli_make_unix_date2(cli, p+8) - cli->serverzone;
	1060	finfo->mtime = cli_make_unix_date2(cli, p+12) - cli->serverzone;
[5]	1061	finfo->size = IVAL(p,16);
	1062	finfo->attr = CVAL(p,24);
	1063	len = CVAL(p, 26);
	1064	p += 27;
	1065	p += clistr_align_in(cli, p, 0);
	1066	/* the len+2 below looks strange but it is
	1067	important to cope with the differences
	1068	between win2000 and win9x for this call
	1069	(tridge) */
	1070	p += clistr_pull(cli, finfo->fname, p,
	1071	sizeof(finfo->fname),
[113]	1072	len+2,
[5]	1073	STR_TERMINATE);
	1074	finfo->easize = -1;
	1075	return PTR_DIFF(p, base);
	1076
	1077	case 2: /* this is what OS/2 uses mostly */
	1078	/* these dates are converted to GMT by
	1079	make_unix_date */
[42]	1080	finfo->ctime = cli_make_unix_date2(cli, p+4) - cli->serverzone;
	1081	finfo->atime = cli_make_unix_date2(cli, p+8) - cli->serverzone;
	1082	finfo->mtime = cli_make_unix_date2(cli, p+12) - cli->serverzone;
[5]	1083	finfo->size = IVAL(p,16);
	1084	finfo->attr = CVAL(p,24);
	1085	finfo->easize = IVAL(p,26);
	1086	len = CVAL(p, 30);
	1087	p += 31;
	1088	/* check for unisys! */
	1089	p += clistr_pull(cli, finfo->fname, p,
	1090	sizeof(finfo->fname),
	1091	len,
	1092	STR_NOALIGN);
	1093	return PTR_DIFF(p, base) + 1;
	1094
	1095	case 260: /* NT uses this, but also accepts 2 */
	1096	{
	1097	size_t namelen, slen;
	1098	p += 4; /* next entry offset */
[6]	1099	if (p_resume_key) {
	1100	*p_resume_key = IVAL(p,0);
	1101	}
[113]	1102
[5]	1103	p += 4; /* fileindex */
	1104
[6]	1105	/* Offset zero is "create time", not "change time". */
[5]	1106	p += 8;
[126]	1107	finfo->atime = interpret_long_date(p).tv_sec;
[5]	1108	p += 8;
[126]	1109	finfo->mtime = interpret_long_date(p).tv_sec;
[5]	1110	p += 8;
[126]	1111	finfo->ctime = interpret_long_date(p).tv_sec;
[5]	1112	p += 8;
	1113	finfo->size = IVAL2_TO_SMB_BIG_UINT(p,0);
	1114	p += 8;
	1115	p += 8; /* alloc size */
	1116	finfo->attr = CVAL(p,0);
	1117	p += 4;
	1118	namelen = IVAL(p,0);
	1119	p += 4;
[25]	1120	finfo->easize = IVAL(p,0);
[5]	1121	p += 4; /* EA size */
	1122	slen = SVAL(p, 0);
	1123	p += 2;
[6]	1124	#if 0
	1125	{
	1126	/* stupid NT bugs. grr */
	1127	int flags = 0;
	1128	if (p[1] == 0 && namelen > 1) flags \|= STR_UNICODE;
	1129	clistr_pull(cli, finfo->short_name, p,
	1130	sizeof(finfo->short_name),
	1131	slen, flags);
	1132	}
	1133	#endif
[5]	1134	p += 24; /* short name? */
	1135	clistr_pull(cli, finfo->fname, p,
	1136	sizeof(finfo->fname),
	1137	namelen, 0);
[6]	1138
	1139	/* To be robust in the face of unicode conversion failures
	1140	we need to copy the raw bytes of the last name seen here.
	1141	Namelen doesn't include the terminating unicode null, so
	1142	copy it here. */
	1143	#if 0
	1144	if (p_last_name_raw && p_last_name_raw_len) {
	1145	if (namelen + 2 > p_last_name_raw->length) {
	1146	memset(p_last_name_raw->data, '\0', sizeof(p_last_name_raw->length));
	1147	*p_last_name_raw_len = 0;
	1148	} else {
	1149	memcpy(p_last_name_raw->data, p, namelen);
	1150	SSVAL(p_last_name_raw->data, namelen, 0);
	1151	*p_last_name_raw_len = namelen + 2;
	1152	}
	1153	}
	1154	#endif
	1155	return (size_t)IVAL(base, 0);
[5]	1156	}
	1157	}
	1158
[24]	1159	debuglocal(1,"Unknown long filename format %d\n",level);
[6]	1160	return (size_t)IVAL(base,0);
[5]	1161	}
	1162
	1163	/****************************************************************************
	1164	Do a directory listing, calling fn on each file found.
	1165	Modified from cli_list_new
	1166	****************************************************************************/
	1167
	1168	static int list_files(struct cli_state cli, const char Mask, uint16 attribute,
[6]	1169	void (fn)(const char, smbwrp_fileinfo , const char , void ), void state)
[5]	1170	{
[6]	1171	#if 1
	1172	int max_matches = 1366; /* Match W2k - was 512. */
	1173	#else
[5]	1174	int max_matches = 512;
[6]	1175	#endif
[5]	1176	int info_level;
	1177	char p, p2;
	1178	pstring mask;
	1179	smbwrp_fileinfo finfo;
	1180	int i;
[110]	1181	char *dirlist = NULL;
[5]	1182	int dirlist_len = 0;
	1183	int total_received = -1;
	1184	BOOL First = True;
	1185	int ff_searchcount=0;
	1186	int ff_eos=0;
	1187	int ff_dir_handle=0;
	1188	int loop_count = 0;
	1189	char rparam=NULL, rdata=NULL;
	1190	unsigned int param_len, data_len;
	1191	uint16 setup;
	1192	pstring param;
[6]	1193	const char *mnt;
	1194	uint32 resume_key = 0;
	1195	uint32 last_name_raw_len = 0;
	1196	DATA_BLOB last_name_raw = data_blob(NULL, 2*sizeof(pstring));
[5]	1197
	1198	/* NT uses 260, OS/2 uses 2. Both accept 1. */
[110]	1199	info_level = (cli->capabilities&CAP_NT_SMBS)?260:2;
[5]	1200
[24]	1201	debuglocal(4,"list_files level %d. mask <%s>\n", info_level, mask);
[5]	1202
[6]	1203	/* when getting a directory listing from a 2k dfs root share,
	1204	we have to include the full path (\server\share\mask) here */
	1205
	1206	if ( cli->dfsroot )
	1207	pstr_sprintf( mask, "\\%s\\%s\\%s", cli->desthost, cli->share, Mask );
	1208	else
	1209	pstrcpy(mask,Mask);
	1210
[5]	1211	while (ff_eos == 0) {
	1212	loop_count++;
	1213	if (loop_count > 200) {
[24]	1214	debuglocal(0,"Error: Looping in FIND_NEXT??\n");
[5]	1215	break;
	1216	}
	1217
	1218	if (First) {
	1219	setup = TRANSACT2_FINDFIRST;
	1220	SSVAL(param,0,attribute); /* attribute */
	1221	SSVAL(param,2,max_matches); /* max count */
[6]	1222	SSVAL(param,4,(FLAG_TRANS2_FIND_REQUIRE_RESUME\|FLAG_TRANS2_FIND_CLOSE_IF_END)); /* resume required + close on end */
[5]	1223	SSVAL(param,6,info_level);
	1224	SIVAL(param,8,0);
	1225	p = param+12;
	1226	p += clistr_push(cli, param+12, mask, sizeof(param)-12,
	1227	STR_TERMINATE);
	1228	} else {
	1229	setup = TRANSACT2_FINDNEXT;
	1230	SSVAL(param,0,ff_dir_handle);
	1231	SSVAL(param,2,max_matches); /* max count */
	1232	SSVAL(param,4,info_level);
[6]	1233	/* For W2K servers serving out FAT filesystems we must set the
	1234	resume key. If it's not FAT then it's returned as zero. */
	1235	SIVAL(param,6,resume_key); /* ff_resume_key */
	1236	/* NB. DON'T use continue here. If you do it seems that W2K and bretheren
	1237	can miss filenames. Use last filename continue instead. JRA */
	1238	SSVAL(param,10,(FLAG_TRANS2_FIND_REQUIRE_RESUME\|FLAG_TRANS2_FIND_CLOSE_IF_END)); /* resume required + close on end */
[5]	1239	p = param+12;
[6]	1240	if (last_name_raw_len && (last_name_raw_len < (sizeof(param)-12))) {
	1241	memcpy(p, last_name_raw.data, last_name_raw_len);
	1242	p += last_name_raw_len;
	1243	} else {
	1244	p += clistr_push(cli, param+12, mask, sizeof(param)-12, STR_TERMINATE);
	1245	}
[5]	1246	}
	1247
	1248	param_len = PTR_DIFF(p, param);
[110]	1249
[5]	1250	if (!cli_send_trans(cli, SMBtrans2,
	1251	NULL, /* Name */
	1252	-1, 0, /* fid, flags */
	1253	&setup, 1, 0, /* setup, length, max */
	1254	param, param_len, 10, /* param, length, max */
	1255	NULL, 0,
	1256	#if 0
	1257	/* w2k value. */
	1258	MIN(16384,cli->max_xmit) /* data, length, max. */
	1259	#else
	1260	cli->max_xmit /* data, length, max. */
	1261	#endif
	1262	)) {
	1263	break;
	1264	}
	1265
	1266	if (!cli_receive_trans(cli, SMBtrans2,
	1267	&rparam, &param_len,
	1268	&rdata, &data_len) &&
	1269	cli_is_dos_error(cli)) {
	1270	/* we need to work around a Win95 bug - sometimes
	1271	it gives ERRSRV/ERRerror temprarily */
	1272	uint8 eclass;
	1273	uint32 ecode;
[6]	1274
	1275	SAFE_FREE(rdata);
	1276	SAFE_FREE(rparam);
	1277
[5]	1278	cli_dos_error(cli, &eclass, &ecode);
[124]	1279
	1280	/*
	1281	* OS/2 might return "no more files",
	1282	* which just tells us, that searchcount is zero
	1283	* in this search.
	1284	* Guenter Kukkukk <linux@kukkukk.com>
	1285	*/
	1286
	1287	if (eclass == ERRDOS && ecode == ERRnofiles) {
	1288	ff_searchcount = 0;
	1289	cli_reset_error(cli);
	1290	break;
	1291	}
	1292
[5]	1293	if (eclass != ERRSRV \|\| ecode != ERRerror)
	1294	break;
	1295	smb_msleep(100);
	1296	continue;
	1297	}
	1298
	1299	if (cli_is_error(cli) \|\| !rdata \|\| !rparam)
	1300	{
	1301	if (First && info_level == 2)
	1302	{
	1303	// we have tried query ea size, but now will try without ea size
	1304	info_level = 1;
[24]	1305	debuglocal(4,"list_files fallback to level %d\n", info_level);
[5]	1306	continue;
	1307	}
[6]	1308	SAFE_FREE(rdata);
	1309	SAFE_FREE(rparam);
[5]	1310	break;
	1311	}
	1312
	1313	if (total_received == -1)
	1314	total_received = 0;
	1315
	1316	/* parse out some important return info */
	1317	p = rparam;
	1318	if (First) {
	1319	ff_dir_handle = SVAL(p,0);
	1320	ff_searchcount = SVAL(p,2);
	1321	ff_eos = SVAL(p,4);
	1322	} else {
	1323	ff_searchcount = SVAL(p,0);
	1324	ff_eos = SVAL(p,2);
	1325	}
[24]	1326	debuglocal(4,"list_files %d %d %d %d\n", ff_searchcount, ff_eos, "(ff_lastname)", First);
[5]	1327
[6]	1328	if (ff_searchcount == 0) {
	1329	SAFE_FREE(rdata);
	1330	SAFE_FREE(rparam);
[5]	1331	break;
[6]	1332	}
[5]	1333
	1334	/* point to the data bytes */
	1335	p = rdata;
	1336
	1337	memset(&finfo, 0, sizeof(finfo));
	1338	finfo.easize = -1;
	1339	/* we might need the lastname for continuations */
[6]	1340	for (p2=p,i=0;i<ff_searchcount;i++) {
	1341	if ((info_level == 260) && (i == ff_searchcount-1)) {
	1342	/* Last entry - fixup the last offset length. */
	1343	SIVAL(p2,0,PTR_DIFF((rdata + data_len),p2));
	1344	}
	1345	p2 += _os2_interpret_long_filename(cli,info_level,p2,&finfo,
	1346	&resume_key,&last_name_raw,&last_name_raw_len);
	1347
	1348	if (!First && *mask && strcsequal(finfo.fname, mask)) {
[24]	1349	debuglocal(0,"Error: Looping in FIND_NEXT as name %s has already been seen?\n",
	1350	finfo.fname);
[6]	1351	ff_eos = 1;
	1352	break;
	1353	}
	1354	}
	1355
	1356	if (ff_searchcount > 0) {
	1357	pstrcpy(mask, finfo.fname);
[5]	1358	} else {
	1359	pstrcpy(mask,"");
	1360	}
[6]	1361
	1362	/* grab the data for later use */
[5]	1363	/* and add them to the dirlist pool */
[6]	1364	dirlist = (char *)SMB_REALLOC(dirlist,dirlist_len + data_len);
[5]	1365
[6]	1366	if (!dirlist) {
[24]	1367	debuglocal(0,"cli_list_new: Failed to expand dirlist\n");
[6]	1368	SAFE_FREE(rdata);
	1369	SAFE_FREE(rparam);
[5]	1370	break;
	1371	}
	1372
	1373	memcpy(dirlist+dirlist_len,p,data_len);
	1374	dirlist_len += data_len;
	1375
	1376	total_received += ff_searchcount;
	1377
	1378	SAFE_FREE(rdata);
	1379	SAFE_FREE(rparam);
	1380
[24]	1381	debuglocal(3,"received %d entries (eos=%d)\n",
	1382	ff_searchcount,ff_eos);
[5]	1383
	1384	if (ff_searchcount > 0)
	1385	loop_count = 0;
	1386
	1387	First = False;
	1388	}
	1389
[6]	1390	mnt = cli_cm_get_mntpoint( cli );
[5]	1391
[6]	1392	/* see if the server disconnected or the connection otherwise failed */
	1393	if (cli_is_error(cli)) {
	1394	total_received = -1;
	1395	} else {
	1396	/* no connection problem. let user function add each entry */
	1397	for (p=dirlist,i=0;i<total_received;i++) {
	1398	p += _os2_interpret_long_filename(cli, info_level, p,
	1399	&finfo,NULL,NULL,NULL);
	1400	fn( mnt,&finfo, Mask, state );
	1401	}
	1402	}
	1403
	1404	/* free up the dirlist buffer and last name raw blob */
[5]	1405	SAFE_FREE(dirlist);
[6]	1406	data_blob_free(&last_name_raw);
[5]	1407	return(total_received);
	1408	}
	1409
	1410
	1411	/*****************************************************
	1412	open a directory on the server
	1413	*******************************************************/
	1414	int _System smbwrp_filelist(smbwrp_server srv, cli_state cli, filelist_state * state)
	1415	{
	1416	if (!srv \|\| !cli \|\| !state \|\| !*state->mask)
	1417	{
	1418	return EINVAL;
	1419	}
[24]	1420	debuglocal(1,"Filelist <%s> on master <%s> wgrp <%s> server <%s> share <%s> clidev <%s>\n", state->mask, srv->master, srv->workgroup, srv->server_name, srv->share_name, cli->dev);
[126]	1421	debug_printf( "Filelist <%s> on master <%s> wgrp <%s> server <%s> share <%s> clidev <%s>\n", state->mask, srv->master, srv->workgroup, srv->server_name, srv->share_name, cli->dev);
[5]	1422	if (srv->workgroup == 0 && srv->server_name == 0)
	1423	{
	1424	smbwrp_special_add(".", state);
	1425	smbwrp_special_add("..", state);
	1426	cli_NetServerEnum(cli, srv->master, SV_TYPE_DOMAIN_ENUM,
	1427	smbwrp_share_add, state);
	1428	} else
	1429	if (*srv->server_name == 0)
	1430	{
	1431	smbwrp_special_add(".", state);
	1432	smbwrp_special_add("..", state);
	1433
	1434	cli_NetServerEnum(cli, srv->workgroup, SV_TYPE_ALL,
	1435	smbwrp_share_add, state);
	1436	} else
	1437	if ((strcmp(cli->dev,"IPC") == 0) \|\| *srv->share_name == 0 \|\| (stricmp(srv->share_name,"IPC$") == 0))
	1438	{
	1439	smbwrp_special_add(".", state);
	1440	smbwrp_special_add("..", state);
[52]	1441
[51]	1442	if (net_share_enum_rpc(cli, smbwrp_share_add, state) < 0 &&
	1443	cli_RNetShareEnum(cli,smbwrp_share_add, state) < 0)
[5]	1444	{
	1445	return os2cli_errno(cli);
	1446	}
	1447	} else
	1448	if (strncmp(cli->dev,"LPT",3) == 0)
	1449	{
	1450	smbwrp_special_add(".", state);
	1451	smbwrp_special_add("..", state);
	1452	if (cli_print_queue_state(cli, smbwrp_printjob_add, state) < 0)
	1453	{
	1454	return os2cli_errno(cli);
	1455	}
	1456	}
	1457	else
	1458	{
	1459	#if 0
	1460	if (strcmp(path,"\\") == 0) {
	1461	smbwrp_special_add(".", state);
	1462	smbwrp_special_add("..", state);
	1463	}
	1464	#endif
	1465	#if 0
	1466	if (cli_list(cli, state->mask, aHIDDEN\|aSYSTEM\|aDIR,
	1467	smbwrp_dir_add_old, state) < 0)
	1468	#else
	1469	if (list_files(cli, state->mask, aHIDDEN\|aSYSTEM\|aDIR,
	1470	smbwrp_dir_add, state) < 0)
	1471	#endif
	1472	{
	1473	return os2cli_errno(cli);
	1474	}
	1475	}
	1476
	1477	return 0;
	1478	}
	1479
	1480	/*****************************************************
	1481	a wrapper for chdir()
	1482	*******************************************************/
[75]	1483	int _System smbwrp_chdir(smbwrp_server srv, cli_state cli, char *fname)
[5]	1484	{
	1485	unsigned short mode = aDIR;
	1486	smbwrp_fileinfo finfo = {0};
	1487	if (!cli \|\| !fname)
	1488	{
	1489	return EINVAL;
	1490	}
	1491
	1492	strncpy(finfo.fname, fname, sizeof(finfo.fname) - 1);
[75]	1493	if (smbwrp_getattr(srv, cli, &finfo))
[5]	1494	{
	1495	return os2cli_errno(cli);
	1496	}
	1497
	1498	if (!(finfo.attr & aDIR)) {
	1499	return ENOTDIR;
	1500	}
	1501
	1502	return 0;
	1503	}
	1504
	1505
	1506	/*****************************************************
	1507	a wrapper for mkdir()
	1508	*******************************************************/
	1509	int _System smbwrp_mkdir(cli_state * cli, char *fname)
	1510	{
	1511	if (!cli \|\| !fname)
	1512	{
	1513	return EINVAL;
	1514	}
	1515
	1516	if (!cli_mkdir(cli, fname))
	1517	{
	1518	return os2cli_errno(cli);
	1519	}
	1520	return 0;
	1521	}
	1522
	1523	/*****************************************************
	1524	a wrapper for rmdir()
	1525	*******************************************************/
	1526	int _System smbwrp_rmdir(cli_state * cli, char *fname)
	1527	{
	1528	if (!cli \|\| !fname)
	1529	{
	1530	return EINVAL;
	1531	}
	1532
	1533	if (!cli_rmdir(cli, fname))
	1534	{
	1535	return os2cli_errno(cli);
	1536	}
	1537	return 0;
	1538	}
	1539
	1540	/*****************************************************
	1541	set EA for a path
	1542	*******************************************************/
	1543	int _System smbwrp_setea(cli_state * cli, char fname, char name, unsigned char * value, int size)
	1544	{
	1545	if (!cli \|\| !fname \|\| !name)
	1546	{
	1547	return EINVAL;
	1548	}
	1549	if (!cli_set_ea_path(cli, fname, name, value, size))
	1550	{
	1551	return os2cli_errno(cli);
	1552	}
	1553	return 0;
	1554	}
	1555
	1556	/*****************************************************
	1557	set EA for a file
	1558	*******************************************************/
	1559	int _System smbwrp_fsetea(cli_state * cli, smbwrp_file file, char name, unsigned char * value, int size)
	1560	{
	1561	if (!cli \|\| !file \|\| !name)
	1562	{
	1563	return EINVAL;
	1564	}
	1565	if (!cli_set_ea_fnum(cli, file->fd, name, value, size))
	1566	{
	1567	return os2cli_errno(cli);
	1568	}
	1569	return 0;
	1570	}
	1571
	1572
	1573	#pragma pack(1)
	1574	typedef struct _FEA /* fea */
	1575	{
	1576	unsigned char fEA; /* flags */
	1577	unsigned char cbName; /* name length not including NULL */
	1578	unsigned short cbValue; /* value length */
	1579	} FEA;
	1580
	1581	typedef struct _FEALIST /* feal */
	1582	{
	1583	unsigned long cbList; /* total bytes of structure including full list */
	1584	FEA list[1]; /* variable length FEA structures */
	1585	} FEALIST;
	1586	#pragma pack()
	1587
	1588	static int unilistea(cli_state * cli, char fname, smbwrp_file file, void * buffer, unsigned long size)
	1589	{
	1590	int fnum, i;
	1591	int gotsize = sizeof(unsigned long);
	1592	size_t num_eas;
	1593	struct ea_struct *ea_list = NULL;
	1594	TALLOC_CTX *mem_ctx;
	1595	FEA * p;
	1596	FEALIST * pfealist;
	1597	char * q;
	1598
	1599	mem_ctx = talloc_init("%d: ealist", _gettid());
	1600	pfealist = (FEALIST *)buffer;
	1601	pfealist->cbList = 0;
	1602
	1603	if (file)
	1604	{
	1605	if (!cli_get_ea_list_fnum(cli, file->fd, mem_ctx, &num_eas, &ea_list))
	1606	{
[24]	1607	debuglocal(4,"ea_get_fnum list failed - %s\n", cli_errstr(cli));
[5]	1608	talloc_destroy(mem_ctx);
	1609	return os2cli_errno(cli);
	1610	}
	1611	}
	1612	else
	1613	{
	1614	if (!cli_get_ea_list_path(cli, fname, mem_ctx, &num_eas, &ea_list))
	1615	{
[24]	1616	debuglocal(4,"ea_get_file list failed - %s\n", cli_errstr(cli));
[5]	1617	talloc_destroy(mem_ctx);
	1618	return os2cli_errno(cli);
	1619	}
	1620	}
	1621
[24]	1622	debuglocal(4,"num_eas = %d\n", num_eas);
[5]	1623
	1624	// we will count that os/2 max EA size for file is 64kb
	1625	p = pfealist->list;
	1626	for (i = 0; i < num_eas; i++)
	1627	{
	1628	int namelen = strlen(ea_list[i].name);
[24]	1629	debuglocal(4, "%d Got EA <%s> with namelen %d, size %d. Gross %d. Buf %d\n", i, ea_list[i].name, namelen, ea_list[i].value.length, gotsize, size);
[5]	1630	if (namelen > 0xFF \|\| ea_list[i].value.length > 0xFFFF)
	1631	{
[24]	1632	debuglocal(4, "Skip EA <%s> with namelen %d, size %d\n", ea_list[i].name, namelen, ea_list[i].value.length);
[5]	1633	continue;
	1634	}
	1635	gotsize += sizeof(FEA) + namelen + ea_list[i].value.length + 1;
	1636	if (size >= gotsize)
	1637	{
	1638	p->fEA = 0;
	1639	p->cbName = namelen;
	1640	p->cbValue = ea_list[i].value.length;
	1641	q = (char *)(p + 1);
	1642	strncpy(q, ea_list[i].name, namelen + 1);
	1643	q += namelen + 1;
	1644	memcpy(q, ea_list[i].value.data, ea_list[i].value.length);
	1645	p = (FEA *)(q + ea_list[i].value.length);
	1646	}
	1647	}
	1648	pfealist->cbList = gotsize;
[24]	1649	debuglocal(4,"ret size = %d\n", gotsize);
[5]	1650
	1651	talloc_destroy(mem_ctx);
	1652	return 0;
	1653	}
	1654
	1655	/*****************************************************
	1656	lists EA of a path
	1657	*******************************************************/
	1658	int _System smbwrp_listea(cli_state * cli, char fname, void buffer, unsigned long size)
	1659	{
	1660	if (!cli \|\| !fname \|\| !buffer)
	1661	{
	1662	return EINVAL;
	1663	}
	1664
[24]	1665	debuglocal(4,"EALIst for <%s>\n", fname);
[5]	1666	return unilistea(cli, fname, NULL, buffer, size);
	1667	}
	1668
	1669	/*****************************************************
	1670	lists EA of a file
	1671	*******************************************************/
	1672	int _System smbwrp_flistea(cli_state * cli, smbwrp_file file, void buffer, unsigned long size)
	1673	{
	1674	if (!cli \|\| !file \|\| !buffer)
	1675	{
	1676	return EINVAL;
	1677	}
	1678
[24]	1679	debuglocal(4,"FEALIst for <%s>/%d\n", file->fname, file->fd);
[5]	1680	return unilistea(cli, NULL, file, buffer, size);
	1681	}
	1682
	1683	/****************************************************************************
	1684	Check the space on a device.
	1685	****************************************************************************/
	1686	int _System smbwrp_dskattr(cli_state * cli, FSALLOCATE *pfsa)
	1687	{
	1688	int total, bsize, avail;
	1689
	1690	if (!cli \|\| !pfsa)
	1691	{
	1692	return EINVAL;
	1693	}
	1694
	1695	if (!cli_dskattr(cli, &bsize, &total, &avail))
	1696	{
[24]	1697	debuglocal(4,"Error in dskattr: %s\n",cli_errstr(cli));
[5]	1698	return os2cli_errno(cli);
	1699	}
	1700
[24]	1701	debuglocal(4,"\n\t\t%d blocks of size %d. %d blocks available\n",
	1702	total, bsize, avail);
[5]	1703
	1704	// YD currently Samba return it in MB!
	1705	pfsa->cSectorUnit = 1;
	1706	if (bsize > 65536)
	1707	{
	1708	pfsa->cUnit = total*1024;
	1709	pfsa->cUnitAvail = avail*1024;
	1710	pfsa->cbSector = bsize/1024;
	1711	}
	1712	else
	1713	{
	1714	pfsa->cUnit = total;
	1715	pfsa->cUnitAvail = avail;
	1716	pfsa->cbSector = bsize;
	1717	}
	1718
	1719	return 0;
	1720	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: