libmlsvc/common/svcctl_svc.c

333 	struct svcctl_Close *param = arg;
334 	ndr_hdid_t *id = (ndr_hdid_t *)&param->handle;
338 	bzero(&param->result_handle, sizeof (svcctl_handle_t));
339 	param->status = ERROR_SUCCESS;
349 	struct svcctl_ControlService *param = arg;
350 	ndr_hdid_t *id = (ndr_hdid_t *)&param->service_handle;
358 		bzero(param, sizeof (struct svcctl_ControlService));
359 		param->status = ERROR_INVALID_HANDLE;
366 		bzero(param, sizeof (struct svcctl_ControlService));
367 		param->status = ERROR_INVALID_HANDLE;
371 	switch (param->control) {
384 		bzero(param, sizeof (struct svcctl_ControlService));
385 		param->status = ERROR_INVALID_PARAMETER;
391 		bzero(param, sizeof (struct svcctl_ControlService));
392 		param->status = ERROR_SERVICE_DOES_NOT_EXIST;
396 	param->service_status.service_type = SERVICE_WIN32_SHARE_PROCESS;
397 	param->service_status.cur_state = svcctl_scm_map_status(svc->sn_state);
398 	param->service_status.ctrl_accepted = 0;
399 	param->service_status.w32_exitcode = 0;
400 	param->service_status.svc_specified_exitcode = 0;
401 	param->service_status.check_point = 0;
402 	param->service_status.wait_hint = 0;
404 	param->status = ERROR_SUCCESS;
414 	struct svcctl_DeleteService *param = arg;
415 	ndr_hdid_t *id = (ndr_hdid_t *)&param->service_handle;
420 		param->status = ERROR_INVALID_HANDLE;
424 	param->status = ERROR_SUCCESS;
434 	struct svcctl_QueryServiceSecurity *param = arg;
435 	ndr_hdid_t *id = (ndr_hdid_t *)&param->service_handle;
447 	sec_info = param->security_info & SMB_ALL_SECINFO;
453 	if (param->buf_size < SVCCTL_SECURITY_BUFSIZE) {
459 	param->buffer = NDR_MALLOC(mxa, SVCCTL_SECURITY_BUFSIZE);
460 	if (param->buffer == NULL) {
465 	bzero(param->buffer, sizeof (SVCCTL_SECURITY_BUFSIZE));
466 	param->buf_size = SVCCTL_SECURITY_BUFSIZE;
467 	param->bytes_needed = 0;
468 	param->status = ERROR_SUCCESS;
472 	bzero(param, sizeof (struct svcctl_QueryServiceSecurity));
473 	param->buf_size = 0;
474 	param->buffer = NDR_MALLOC(mxa, sizeof (uint32_t));
475 	param->bytes_needed = bytes_needed;
476 	param->status = status;
487 	struct svcctl_SetServiceSecurity *param = arg;
488 	ndr_hdid_t *id = (ndr_hdid_t *)&param->service_handle;
493 		param->status = ERROR_INVALID_HANDLE;
497 	if ((param->security_info & SMB_ALL_SECINFO) == 0) {
498 		param->status = ERROR_INVALID_PARAMETER;
502 	param->status = ERROR_ACCESS_DENIED;
522 	struct svcctl_OpenManager *param = arg;
528 	if ((rc == 0) || (param->desired_access & SC_MANAGER_LOCK) != 0) {
529 		bzero(&param->handle, sizeof (svcctl_handle_t));
530 		param->status = ERROR_ACCESS_DENIED;
536 		bcopy(id, &param->handle, sizeof (svcctl_handle_t));
537 		param->status = ERROR_SUCCESS;
539 		bzero(&param->handle, sizeof (svcctl_handle_t));
540 		param->status = ERROR_ACCESS_DENIED;
560 	struct svcctl_OpenService *param = arg;
561 	ndr_hdid_t *mgrid = (ndr_hdid_t *)&param->manager_handle;
566 	char *svc_name = (char *)param->service_name;
571 	    SVCCTL_OPENSVC_OP_UNIMPLEMENTED(param->desired_access);
574 		bzero(&param->service_handle, sizeof (svcctl_handle_t));
575 		param->status = ERROR_CALL_NOT_IMPLEMENTED;
581 		bzero(&param->service_handle, sizeof (svcctl_handle_t));
582 		param->status = ERROR_INVALID_HANDLE;
589 		bzero(&param->service_handle, sizeof (svcctl_handle_t));
590 		param->status = status;
596 		bcopy(id, &param->service_handle, sizeof (svcctl_handle_t));
597 		param->status = ERROR_SUCCESS;
599 		bzero(&param->service_handle, sizeof (svcctl_handle_t));
600 		param->status = ERROR_ACCESS_DENIED;
616 	struct svcctl_QueryServiceStatus *param = arg;
617 	ndr_hdid_t *id = (ndr_hdid_t *)&param->service_handle;
625 		bzero(param, sizeof (struct svcctl_QueryServiceStatus));
626 		param->status = ERROR_INVALID_HANDLE;
633 		bzero(param, sizeof (struct svcctl_QueryServiceStatus));
634 		param->status = ERROR_INVALID_HANDLE;
640 		bzero(param, sizeof (struct svcctl_QueryServiceStatus));
641 		param->status = ERROR_SERVICE_DOES_NOT_EXIST;
645 	param->service_status.service_type = SERVICE_WIN32_SHARE_PROCESS;
646 	param->service_status.cur_state = svcctl_scm_map_status(svc->sn_state);
647 	param->service_status.ctrl_accepted = 0;
648 	param->service_status.w32_exitcode = 0;
649 	param->service_status.svc_specified_exitcode = 0;
650 	param->service_status.check_point = 0;
651 	param->service_status.wait_hint = 0;
653 	param->status = ERROR_SUCCESS;
665 	struct svcctl_EnumDependentServices *param = arg;
666 	ndr_hdid_t *id = (ndr_hdid_t *)&param->service_handle;
693 	switch (param->svc_state) {
707 	if ((input_bufsize = param->buf_size) == 0) {
708 		bzero(param, sizeof (struct svcctl_EnumDependentServices));
709 		param->buf_size = input_bufsize;
710 		param->services = NDR_STRDUP(mxa, "");
711 		param->bytes_needed = 1024;
712 		param->svc_num = 0;
713 		param->status = ERROR_MORE_DATA;
717 	param->services = NDR_MALLOC(mxa, input_bufsize);
718 	if (param->services == NULL) {
723 	bzero(param->services, input_bufsize);
724 	param->buf_size = input_bufsize;
725 	param->bytes_needed = 0;
726 	param->svc_num = 0;
727 	param->status = ERROR_SUCCESS;
731 	bzero(param, sizeof (struct svcctl_EnumDependentServices));
732 	param->services = NDR_STRDUP(mxa, "");
733 	param->status = status;
745 	struct svcctl_EnumServicesStatus *param = arg;
746 	ndr_hdid_t *id = (ndr_hdid_t *)&param->manager_handle;
754 	if (param->resume_handle != NULL)
755 		resume_handle = *param->resume_handle;
769 	buf_size = param->buf_size;
770 	param->services = NDR_MALLOC(mxa, buf_size);
771 	if (param->services == NULL) {
775 	bzero(param->services, buf_size);
778 		param->bytes_needed = mgr_ctx->mc_bytes_needed;
779 		param->svc_num = 0;
780 		if (param->resume_handle)
781 			*param->resume_handle = 0;
782 		param->status = ERROR_MORE_DATA;
786 	svc_num = svcctl_scm_enum_services(mgr_ctx, param->services,
789 	param->buf_size = buf_size;
790 	param->svc_num = svc_num;
793 		if (param->resume_handle != NULL)
794 			*param->resume_handle = resume_handle;
795 		param->bytes_needed = mgr_ctx->mc_bytes_needed;
796 		param->status = ERROR_MORE_DATA;
798 		if (param->resume_handle)
799 			*param->resume_handle = 0;
800 		param->bytes_needed = 0;
801 		param->status = ERROR_SUCCESS;
806 	bzero(param, sizeof (struct svcctl_EnumServicesStatus));
807 	param->services = NDR_STRDUP(mxa, "");
808 	param->status = status;
822 	struct svcctl_QueryServiceConfig *param = arg;
823 	ndr_hdid_t *id = (ndr_hdid_t *)&param->service_handle;
833 		bzero(param, sizeof (struct svcctl_QueryServiceConfig));
834 		param->status = ERROR_INVALID_HANDLE;
841 		bzero(param, sizeof (struct svcctl_QueryServiceConfig));
842 		param->status = ERROR_INVALID_HANDLE;
848 		bzero(param, sizeof (struct svcctl_QueryServiceConfig));
849 		param->status = ERROR_SERVICE_DOES_NOT_EXIST;
853 	cfg = &param->service_cfg;
871 	if (param->buf_size < bytes_needed) {
872 		bzero(param, sizeof (struct svcctl_QueryServiceConfig));
873 		param->cfg_bytes = bytes_needed;
874 		param->status = ERROR_INSUFFICIENT_BUFFER;
878 	param->cfg_bytes = bytes_needed;
879 	param->status = ERROR_SUCCESS;
889 	struct svcctl_StartService *param = arg;
890 	ndr_hdid_t *id = (ndr_hdid_t *)&param->service_handle;
898 		param->status = ERROR_INVALID_HANDLE;
905 		param->status = ERROR_INVALID_HANDLE;
911 		param->status = ERROR_SERVICE_DOES_NOT_EXIST;
913 		param->status = ERROR_SERVICE_ALREADY_RUNNING;
929 	struct svcctl_GetServiceDisplayNameW *param = arg;
930 	ndr_hdid_t *id = (ndr_hdid_t *)&param->manager_handle;
937 		bzero(param, sizeof (struct svcctl_GetServiceDisplayNameW));
938 		param->display_name = NDR_STRDUP(mxa, "");
939 		param->status = ERROR_INVALID_HANDLE;
944 	svc = svcctl_scm_find_service(mgr_ctx, (char *)param->service_name);
946 		bzero(param, sizeof (struct svcctl_GetServiceDisplayNameW));
947 		param->display_name = NDR_STRDUP(mxa, "");
948 		param->status = ERROR_SERVICE_DOES_NOT_EXIST;
952 	param->display_name = NDR_STRDUP(mxa, svc->sn_fmri);
953 	if (param->display_name == NULL) {
954 		bzero(param, sizeof (struct svcctl_GetServiceDisplayNameW));
955 		param->display_name = NDR_STRDUP(mxa, "");
956 		param->status = ERROR_NOT_ENOUGH_MEMORY;
960 	param->buf_size = strlen(svc->sn_fmri);
961 	param->status = ERROR_SUCCESS;
976 	struct svcctl_GetServiceKeyNameW *param = arg;
977 	ndr_hdid_t *id = (ndr_hdid_t *)&param->manager_handle;
984 		bzero(param, sizeof (struct svcctl_GetServiceKeyNameW));
985 		param->key_name = NDR_STRDUP(mxa, "");
986 		param->status = ERROR_INVALID_HANDLE;
991 	svc = svcctl_scm_find_service(mgr_ctx, (char *)param->service_name);
993 		bzero(param, sizeof (struct svcctl_GetServiceKeyNameW));
994 		param->key_name = NDR_STRDUP(mxa, "");
995 		param->status = ERROR_SERVICE_DOES_NOT_EXIST;
999 	param->key_name = NDR_STRDUP(mxa, svc->sn_name);
1000 	if (param->key_name == NULL) {
1001 		bzero(param, sizeof (struct svcctl_GetServiceKeyNameW));
1002 		param->key_name = NDR_STRDUP(mxa, "");
1003 		param->status = ERROR_NOT_ENOUGH_MEMORY;
1007 	param->buf_size = strlen(svc->sn_name);
1008 	param->status = ERROR_SUCCESS;
1028 	struct svcctl_OpenSCManagerA *param = arg;
1034 	if ((rc == 0) || (param->desired_access & SC_MANAGER_LOCK) != 0) {
1035 		bzero(&param->handle, sizeof (svcctl_handle_t));
1036 		param->status = ERROR_ACCESS_DENIED;
1042 		bcopy(id, &param->handle, sizeof (svcctl_handle_t));
1043 		param->status = ERROR_SUCCESS;
1045 		bzero(&param->handle, sizeof (svcctl_handle_t));
1046 		param->status = ERROR_ACCESS_DENIED;
1066 	struct svcctl_OpenServiceA *param = arg;
1067 	ndr_hdid_t *mgrid = (ndr_hdid_t *)&param->manager_handle;
1072 	char *svc_name = (char *)param->service_name->value;
1077 	    SVCCTL_OPENSVC_OP_UNIMPLEMENTED(param->desired_access);
1080 		bzero(&param->service_handle, sizeof (svcctl_handle_t));
1081 		param->status = ERROR_CALL_NOT_IMPLEMENTED;
1087 		bzero(&param->service_handle, sizeof (svcctl_handle_t));
1088 		param->status = ERROR_INVALID_HANDLE;
1095 		bzero(&param->service_handle, sizeof (svcctl_handle_t));
1096 		param->status = status;
1102 		bcopy(id, &param->service_handle, sizeof (svcctl_handle_t));
1103 		param->status = ERROR_SUCCESS;
1105 		bzero(&param->service_handle, sizeof (svcctl_handle_t));
1106 		param->status = ERROR_ACCESS_DENIED;
1120 	struct svcctl_EnumServicesStatusA *param = arg;
1121 	ndr_hdid_t *id = (ndr_hdid_t *)&param->manager_handle;
1129 	buf_size = param->buf_size;
1130 	if (param->resume_handle != NULL)
1131 		resume_handle = *param->resume_handle;
1145 	param->services = NDR_MALLOC(mxa, buf_size);
1146 	if (param->services == NULL) {
1150 	bzero(param->services, buf_size);
1152 	svc_num = svcctl_scm_enum_services(mgr_ctx, param->services,
1155 	param->buf_size = buf_size;
1156 	param->svc_num = svc_num;
1159 		if (param->resume_handle != NULL)
1160 			*param->resume_handle = resume_handle;
1161 		param->bytes_needed = mgr_ctx->mc_bytes_needed;
1162 		param->status = ERROR_MORE_DATA;
1164 		if (param->resume_handle)
1165 			*param->resume_handle = 0;
1166 		param->bytes_needed = 0;
1167 		param->status = ERROR_SUCCESS;
1172 	bzero(param, sizeof (struct svcctl_EnumServicesStatusA));
1173 	param->services = NDR_STRDUP(mxa, "");
1174 	param->status = status;
1190 	struct svcctl_QueryServiceConfig2W *param = arg;
1191 	ndr_hdid_t *id = (ndr_hdid_t *)&param->service_handle;
1204 		bzero(param, sizeof (struct svcctl_QueryServiceConfig2W));
1205 		param->buffer = NDR_STRDUP(mxa, "");
1206 		param->status = ERROR_INVALID_HANDLE;
1210 	input_bufsize = param->buf_size;
1211 	param->buffer = NDR_MALLOC(mxa, input_bufsize);
1212 	if (param->buffer == NULL) {
1213 		bzero(param, sizeof (struct svcctl_QueryServiceConfig2W));
1214 		param->buffer = NDR_STRDUP(mxa, "");
1215 		param->status = ERROR_NOT_ENOUGH_MEMORY;
1218 	bzero(param->buffer, input_bufsize);
1220 	svc_rsp.svc_buf = param->buffer;
1222 	switch (param->info_level) {
1227 			param->status = ERROR_INVALID_HANDLE;
1241 			param->bytes_needed = bytes_needed;
1242 			param->status = ERROR_INSUFFICIENT_BUFFER;
1249 		wide_desc = (smb_wchar_t *)&param->buffer[offset];
1253 		param->bytes_needed = offset;
1260 			param->bytes_needed = bytes_needed;
1261 			param->status = ERROR_INSUFFICIENT_BUFFER;
1264 		param->bytes_needed = bytes_needed;
1269 		param->bytes_needed = sizeof (svc_delayed_auto_start_t);
1274 		param->bytes_needed = sizeof (svc_config_failure_action_t);
1288 		bzero(param, sizeof (struct svcctl_QueryServiceConfig2W));
1289 		param->buffer = NDR_STRDUP(mxa, "");
1290 		param->status = status;
1294 	param->status = ERROR_SUCCESS;
1304 	struct svcctl_QueryServiceStatusEx *param = arg;
1305 	ndr_hdid_t *id = (ndr_hdid_t *)&param->service_handle;
1328 	if (param->info_level != SC_STATUS_PROCESS_INFO) {
1335 	if ((input_bufsize = param->buf_size) < bytes_needed) {
1336 		bzero(param, sizeof (struct svcctl_QueryServiceStatusEx));
1337 		param->buf_size = input_bufsize;
1338 		param->buffer = NDR_STRDUP(mxa, "");
1339 		param->bytes_needed = bytes_needed;
1340 		param->status = ERROR_INSUFFICIENT_BUFFER;
1365 	param->buffer = (uint8_t *)svc_status_ex;
1366 	param->buf_size = input_bufsize;
1367 	param->bytes_needed = bytes_needed;
1368 	param->status = ERROR_SUCCESS;
1372 	bzero(param, sizeof (struct svcctl_QueryServiceStatusEx));
1373 	param->buffer = NDR_STRDUP(mxa, "");
1374 	param->status = status;