dcesrv_srvsvc.c

来自「samba最新软件」· C语言 代码 · 共 2,328 行 · 第 1/4 页

	case 501:
	case 1:
		info[i].name = SHARE_TYPE;
		info[i].type = SHARE_INFO_STRING;
		switch (type) {
		case 0x00:
			info[i].value = talloc_strdup(info, "DISK");
			break;
		case 0x01:
			info[i].value = talloc_strdup(info, "PRINTER");
			break;
		case 0x03:
			info[i].value = talloc_strdup(info, "IPC");
			break;
		default:
			return WERR_INVALID_PARAM;
		}
		W_ERROR_HAVE_NO_MEMORY(info[i].value);
		i++;

	case 1004:
		if (comment) {
			info[i].name = SHARE_COMMENT;
			info[i].type = SHARE_INFO_STRING;
			info[i].value = talloc_strdup(info, comment);
			W_ERROR_HAVE_NO_MEMORY(info[i].value);

			i++;
		}
	case 0:
		if (name &&
		    strcasecmp(share_name, name) != 0) {
			info[i].name = SHARE_NAME;
			info[i].type = SHARE_INFO_STRING;
			info[i].value = talloc_strdup(info, name);
			W_ERROR_HAVE_NO_MEMORY(info[i].value);
			i++;
		}

		break;

	default:
		return WERR_UNKNOWN_LEVEL;
	}

	*count = i;

	return WERR_OK;
}

/* 
  srvsvc_NetShareSetInfo 
*/
static WERROR dcesrv_srvsvc_NetShareSetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
		       struct srvsvc_NetShareSetInfo *r)
{
	NTSTATUS nterr;
	WERROR status;
	struct share_context *sctx = NULL;
	struct share_info *info;
	int count;

	/* TODO: - access check
	 */

	/* there are no more than 10 options in all struct srvsvc_NetShareInfoXXX */
	info = talloc_array(mem_ctx, struct share_info, 10);
	W_ERROR_HAVE_NO_MEMORY(info);

	ZERO_STRUCT(r->out);

	if (strcmp("", r->in.share_name) == 0) {
		return WERR_INVALID_PARAM;
	}

	nterr = share_get_context_by_name(mem_ctx, lp_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
	if (!NT_STATUS_IS_OK(nterr)) {
		return ntstatus_to_werror(nterr);
	}

	switch (r->in.level) {
	case 0:
	{
		status = dcesrv_srvsvc_fill_share_info(info, &count,
					r->in.share_name, r->in.level,
					r->in.info.info0->name,
					NULL,
					NULL,
					NULL,
					0,
					0,
					0,
					NULL);
		if (W_ERROR_EQUAL(status, WERR_OK)) {
			return status;
		}
		break;
	}
	case 1:
	{
		status = dcesrv_srvsvc_fill_share_info(info, &count,
					r->in.share_name, r->in.level,
					r->in.info.info1->name,
					NULL,
					r->in.info.info1->comment,
					NULL,
					r->in.info.info1->type,
					0,
					0,
					NULL);
		if (W_ERROR_EQUAL(status, WERR_OK)) {
			return status;
		}
		break;
	}
	case 2:
	{
		status = dcesrv_srvsvc_fill_share_info(info, &count,
					r->in.share_name, r->in.level,
					r->in.info.info2->name,
					r->in.info.info2->path,
					r->in.info.info2->comment,
					r->in.info.info2->password,
					r->in.info.info2->type,
					r->in.info.info2->max_users,
					0,
					NULL);
		if (W_ERROR_EQUAL(status, WERR_OK)) {
			return status;
		}
		break;
	}
	case 501:
	{
		status = dcesrv_srvsvc_fill_share_info(info, &count,
					r->in.share_name, r->in.level,
					r->in.info.info501->name,
					NULL,
					r->in.info.info501->comment,
					NULL,
					r->in.info.info501->type,
					0,
					r->in.info.info501->csc_policy,
					NULL);
		if (W_ERROR_EQUAL(status, WERR_OK)) {
			return status;
		}
		break;
	}
	case 502:
	{
		status = dcesrv_srvsvc_fill_share_info(info, &count,
					r->in.share_name, r->in.level,
					r->in.info.info502->name,
					r->in.info.info502->path,
					r->in.info.info502->comment,
					r->in.info.info502->password,
					r->in.info.info502->type,
					r->in.info.info502->max_users,
					0,
					r->in.info.info502->sd);
		if (W_ERROR_EQUAL(status, WERR_OK)) {
			return status;
		}
		break;
	}
	case 1004:
	{
		status = dcesrv_srvsvc_fill_share_info(info, &count,
					r->in.share_name, r->in.level,
					NULL,
					NULL,
					r->in.info.info1004->comment,
					NULL,
					0,
					0,
					0,
					NULL);
		if (W_ERROR_EQUAL(status, WERR_OK)) {
			return status;
		}
		break;
	}
	case 1005:
	{
		/* r->in.info.dfs_flags; */
		
		if (r->in.parm_error) {
			r->out.parm_error = r->in.parm_error;
		}

		return WERR_OK;
	}
	default:
		return WERR_UNKNOWN_LEVEL;
	}

	nterr = share_set(sctx, r->in.share_name, info, count);
	if (!NT_STATUS_IS_OK(nterr)) {
		return ntstatus_to_werror(nterr);
	}

	if (r->in.parm_error) {
		r->out.parm_error = r->in.parm_error;
	}
		
	return WERR_OK;
}


/* 
  srvsvc_NetShareDelSticky 
*/
static WERROR dcesrv_srvsvc_NetShareDelSticky(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
		       struct srvsvc_NetShareDelSticky *r)
{
	DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
}


/* 
  srvsvc_NetShareCheck 
*/
static WERROR dcesrv_srvsvc_NetShareCheck(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
		       struct srvsvc_NetShareCheck *r)
{
	NTSTATUS nterr;
	struct share_context *sctx = NULL;
	struct share_config *scfg = NULL;
	char *device;
	const char **names;
	int count, i;

	ZERO_STRUCT(r->out);

	/* TODO: - access check
	 */

	if (strcmp("", r->in.device_name) == 0) {
		r->out.type = STYPE_IPC;
		return WERR_OK;
	}

	/* copy the path skipping C:\ */
	if (strncasecmp(r->in.device_name, "C:", 2) == 0) {
		device = talloc_strdup(mem_ctx, &r->in.device_name[2]);
	} else {
		/* no chance we have a share that doesn't start with C:\ */
		return WERR_DEVICE_NOT_SHARED;
	}
	all_string_sub(device, "\\", "/", 0);

	nterr = share_get_context_by_name(mem_ctx, lp_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
	if (!NT_STATUS_IS_OK(nterr)) {
		return ntstatus_to_werror(nterr);
	}

	nterr = share_list_all(mem_ctx, sctx, &count, &names);
	if (!NT_STATUS_IS_OK(nterr)) {
		return ntstatus_to_werror(nterr);
	}

	for (i = 0; i < count; i++) {
		const char *path;
		const char *type;

		nterr = share_get_config(mem_ctx, sctx, names[i], &scfg);
		if (!NT_STATUS_IS_OK(nterr)) {
			return ntstatus_to_werror(nterr);
		}
		path = share_string_option(scfg, SHARE_PATH, NULL);
		if (!path) continue;

		if (strcmp(device, path) == 0) {		
			type = share_string_option(scfg, SHARE_TYPE, NULL);
			if (!type) continue;

			if (strcmp(type, "DISK") == 0) {
				r->out.type = STYPE_DISKTREE;
				return WERR_OK;
			}

			if (strcmp(type, "IPC") == 0) {
				r->out.type = STYPE_IPC;
				return WERR_OK;
			}

			if (strcmp(type, "PRINTER") == 0) {
				r->out.type = STYPE_PRINTQ;
				return WERR_OK;
			}
		}
	}

	return WERR_DEVICE_NOT_SHARED;
}


/* 
  srvsvc_NetSrvGetInfo 
*/
static WERROR dcesrv_srvsvc_NetSrvGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
		       struct srvsvc_NetSrvGetInfo *r)
{
	struct dcesrv_context *dce_ctx = dce_call->conn->dce_ctx;

	ZERO_STRUCT(r->out);

	switch (r->in.level) {
	case 100:
	{
		struct srvsvc_NetSrvInfo100 *info100;

		info100 = talloc(mem_ctx, struct srvsvc_NetSrvInfo100);
		W_ERROR_HAVE_NO_MEMORY(info100);

		info100->platform_id	= dcesrv_common_get_platform_id(mem_ctx, dce_ctx);
		info100->server_name	= dcesrv_common_get_server_name(mem_ctx, dce_ctx, r->in.server_unc);
		W_ERROR_HAVE_NO_MEMORY(info100->server_name);

		r->out.info.info100 = info100;
		return WERR_OK;
	}
	case 101:
	{
		struct srvsvc_NetSrvInfo101 *info101;

		info101 = talloc(mem_ctx, struct srvsvc_NetSrvInfo101);
		W_ERROR_HAVE_NO_MEMORY(info101);

		info101->platform_id	= dcesrv_common_get_platform_id(mem_ctx, dce_ctx);
		info101->server_name	= dcesrv_common_get_server_name(mem_ctx, dce_ctx, r->in.server_unc);
		W_ERROR_HAVE_NO_MEMORY(info101->server_name);

		info101->version_major	= dcesrv_common_get_version_major(mem_ctx, dce_ctx->lp_ctx);
		info101->version_minor	= dcesrv_common_get_version_minor(mem_ctx, dce_ctx->lp_ctx);
		info101->server_type	= dcesrv_common_get_server_type(mem_ctx, dce_call->event_ctx, dce_ctx);
		info101->comment	= talloc_strdup(mem_ctx, lp_serverstring(dce_ctx->lp_ctx));
		W_ERROR_HAVE_NO_MEMORY(info101->comment);

		r->out.info.info101 = info101;
		return WERR_OK;
	}
	case 102:
	{
		struct srvsvc_NetSrvInfo102 *info102;

		info102 = talloc(mem_ctx, struct srvsvc_NetSrvInfo102);
		W_ERROR_HAVE_NO_MEMORY(info102);

		info102->platform_id	= dcesrv_common_get_platform_id(mem_ctx, dce_ctx);
		info102->server_name	= dcesrv_common_get_server_name(mem_ctx, dce_ctx, r->in.server_unc);
		W_ERROR_HAVE_NO_MEMORY(info102->server_name);

		info102->version_major	= dcesrv_common_get_version_major(mem_ctx, dce_ctx->lp_ctx);
		info102->version_minor	= dcesrv_common_get_version_minor(mem_ctx, dce_ctx->lp_ctx);
		info102->server_type	= dcesrv_common_get_server_type(mem_ctx, dce_call->event_ctx, dce_ctx);
		info102->comment	= talloc_strdup(mem_ctx, lp_serverstring(dce_ctx->lp_ctx));
		W_ERROR_HAVE_NO_MEMORY(info102->comment);

		info102->users		= dcesrv_common_get_users(mem_ctx, dce_ctx);
		info102->disc		= dcesrv_common_get_disc(mem_ctx, dce_ctx);
		info102->hidden		= dcesrv_common_get_hidden(mem_ctx, dce_ctx);
		info102->announce	= dcesrv_common_get_announce(mem_ctx, dce_ctx);
		info102->anndelta	= dcesrv_common_get_anndelta(mem_ctx, dce_ctx);
		info102->licenses	= dcesrv_common_get_licenses(mem_ctx, dce_ctx);
		info102->userpath	= dcesrv_common_get_userpath(mem_ctx, dce_ctx);
		W_ERROR_HAVE_NO_MEMORY(info102->userpath);

		r->out.info.info102 = info102;
		return WERR_OK;
	}
	default:
		return WERR_UNKNOWN_LEVEL;
	}

	return WERR_UNKNOWN_LEVEL;
}


/* 
  srvsvc_NetSrvSetInfo 
*/
static WERROR dcesrv_srvsvc_NetSrvSetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
		       struct srvsvc_NetSrvSetInfo *r)
{
	DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
}


/* 
  srvsvc_NetDiskEnum 
*/
static WERROR dcesrv_srvsvc_NetDiskEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
		       struct srvsvc_NetDiskEnum *r)
{
	r->out.info.disks = NULL;
	r->out.info.count = 0;
	r->out.totalentries = 0;
	r->out.resume_handle = NULL;

	switch (r->in.level) {
	case 0:
	{
		/* we can safely hardcode the reply and report we have only one disk (C:) */
		/* for some reason Windows wants 2 entries with the second being empty */
		r->out.info.disks = talloc_array(mem_ctx, struct srvsvc_NetDiskInfo0, 2);
		W_ERROR_HAVE_NO_MEMORY(r->out.info.disks);
		r->out.info.count = 2;

		r->out.info.disks[0].disk = talloc_strdup(mem_ctx, "C:");
		W_ERROR_HAVE_NO_MEMORY(r->out.info.disks[0].disk);

		r->out.info.disks[1].disk = talloc_strdup(mem_ctx, "");
		W_ERROR_HAVE_NO_MEMORY(r->out.info.disks[1].disk);

		r->out.totalentries = 1;
		r->out.resume_handle = r->in.resume_handle;

		return WERR_OK;
	}
	default:
		return WERR_UNKNOWN_LEVEL;
	}

	return WERR_UNKNOWN_LEVEL;
}


/* 
  srvsvc_NetServerStatisticsGet 
*/
static WERROR dcesrv_srvsvc_NetServerStatisticsGet(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
		       struct srvsvc_NetServerStatisticsGet *r)
{
	DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
}


/* 
  srvsvc_NetTransportAdd 
*/
static WERROR dcesrv_srvsvc_NetTransportAdd(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
		       struct srvsvc_NetTransportAdd *r)
{
	DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
}


/* 
  srvsvc_NetTransportEnum 
*/
static WERROR dcesrv_srvsvc_NetTransportEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
		       struct srvsvc_NetTransportEnum *r)
{
	r->out.level = r->in.level;
	r->out.totalentries = 0;
	r->out.resume_handle = NULL;

	switch (r->in.level) {
	case 0:
	{
		r->out.transports.ctr0 = talloc(mem_ctx, struct srvsvc_NetTransportCtr0);
		W_ERROR_HAVE_NO_MEMORY(r->out.transports.ctr0);

		r->out.transports.ctr0->count = 0;
		r->out.transports.ctr0->array = NULL;

		return WERR_NOT_SUPPORTED;
	}
	case 1:
	{
		r->out.transports.ctr1 = talloc(mem_ctx, struct srvsvc_NetTransportCtr1);
		W_ERROR_HAVE_NO_MEMORY(r->out.transports.ctr1);

		r->out.transports.ctr1->count = 0;
		r->out.transports.ctr1->array = NULL;

		return WERR_NOT_SUPPORTED;
	}
	case 2:
	{
		r->out.transports.ctr2 = talloc(mem_ctx, struct srvsvc_NetTransportCtr2);
		W_ERROR_HAVE_NO_MEMORY(r->out.transports.ctr2);

		r->out.transports.ctr2->count = 0;
		r->out.transports.ctr2->array = NULL;

		return WERR_NOT_SUPPORTED;
	}
	case 3:
	{
		r->out.transports.ctr3 = talloc(mem_ctx, struct srvsvc_NetTransportCtr3);
		W_ERROR_HAVE_NO_MEMORY(r->out.transports.ctr3);

		r->out.transports.ctr3->count = 0;
		r->out.transports.ctr3->array = NULL;

		return WERR_NOT_SUPPORTED;
	}
	default:
		return WERR_UNKNOWN_LEVEL;
	}

	return WERR_UNKNOWN_LEVEL;
}

/* 
  srvsvc_NetTransportDel 
*/
static WERROR dcesrv_srvsvc_NetTransportDel(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
		       struct srvsvc_NetTransportDel *r)
{
	DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
}


/* 
  srvsvc_NetRemoteTOD 
*/
static WERROR dcesrv_srvsvc_NetRemoteTOD(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
		       struct srvsvc_NetRemoteTOD *r)
{
	struct timeval tval;
	time_t t;
	struct tm tm;

	r->out.info = talloc(mem_ctx, struct srvsvc_NetRemoteTODInfo);
	W_ERROR_HAVE_NO_MEMORY(r->out.info);

	GetTimeOfDay(&tval);
	t = tval.tv_sec;

	gmtime_r(&t, &tm);

	r->out.info->elapsed	= t;
	/* TODO: fake the uptime: just return the milliseconds till 0:00:00 today */
	r->out.info->msecs	= (tm.tm_hour*60*60*1000)
				+ (tm.tm_min*60*1000)
				+ (tm.tm_sec*1000)
				+ (tval.tv_usec/1000);
	r->out.info->hours	= tm.tm_hour;
	r->out.info->mins	= tm.tm_min;
	r->out.info->secs	= tm.tm_sec;
	r->out.info->hunds	= tval.tv_usec/10000;
	r->out.info->timezone	= get_time_zone(t)/60;
	r->out.info->tinterval	= 310; /* just return the same as windows */
	r->out.info->day	= tm.tm_mday;
	r->out.info->month	= tm.tm_mon + 1;
	r->out.info->year	= tm.tm_year + 1900;
	r->out.info->weekday	= tm.tm_wday;

	return WERR_OK;
}

/* 
  srvsvc_NetPathType 
*/
static WERROR dcesrv_srvsvc_NetPathType(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
		       struct srvsvc_NetPathType *r)
{
	DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
}


/* 
  srvsvc_NetPathCanonicalize 
*/
static WERROR dcesrv_srvsvc_NetPathCanonicalize(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
		       struct srvsvc_NetPathCanonicalize *r)
{
	DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
}


/* 
  srvsvc_NetPathCompare 
*/
static WERROR dcesrv_srvsvc_NetPathCompare(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
		       struct srvsvc_NetPathCompare *r)
{