int ts_engine_client_stop(struct ts_engine_client *client) { int ret; ret = send_and_receive(client, TS_ENGINE_STOP, NULL, 0); if (ret < 0) { eng_dbg("send_and_receive failed\n"); return ERROR; } return OK; }
int ts_engine_client_reload_profile(struct ts_engine_client *client) { int ret; ret = send_and_receive(client, TS_ENGINE_RELOAD_PROFILE, NULL, 0); if (ret < 0) { eng_dbg("send_and_receive failed\n"); return ERROR; } return OK; }
int ts_engine_client_read_device_property(struct ts_engine_client *client) { int ret; ret = send_and_receive(client, TS_ENGINE_READ_DEVICE_PROPERTY, NULL, 0); if (ret < 0) { eng_dbg("send_and_receive failed\n"); return ERROR; } return OK; }
int ts_engine_client_write_cloud_property(struct ts_engine_client *client, const char * const data, size_t len) { int ret; ret = send_and_receive(client, TS_ENGINE_WRITE_CLOUD_PROPERTY, data, len); if (ret < 0) { eng_dbg("send_and_receive failed\n"); return ERROR; } return OK; }
enum STATUS_RESPONSE process_command (int fd, struct Command_ATSHA204 *c, uint8_t* rec_buf, unsigned int recv_len) { unsigned int c_len = 0; uint8_t *serialized; assert (NULL != c); assert (NULL != rec_buf); c_len = serialize_command (c, &serialized); return send_and_receive (fd, serialized, c_len, rec_buf, recv_len, &c->exec_time); }
/* * Confirm our ability to communicate with the board. This test assumes no * other message activity is present */ int loopback(int card) { int status; static char testmsg[] = "Test Message"; RspMessage rspmsg; if(!IS_VALID_CARD(card)) { pr_debug("Invalid param: %d is not a valid card id\n", card); return -ENODEV; } pr_debug("%s: Sending loopback message\n", adapter[card]->devicename); /* * Send the loopback message to confirm that memory transfer is * operational */ status = send_and_receive(card, CMPID, cmReqType1, cmReqClass0, cmReqMsgLpbk, 0, (unsigned char) strlen(testmsg), (unsigned char *)testmsg, &rspmsg, SAR_TIMEOUT); if (!status) { pr_debug("%s: Loopback message successfully sent\n", adapter[card]->devicename); if(strcmp(rspmsg.msg_data.byte_array, testmsg)) { pr_debug("%s: Loopback return != sent\n", adapter[card]->devicename); return -EIO; } return 0; } else { pr_debug("%s: Send loopback message failed\n", adapter[card]->devicename); return -EIO; } }
int ts_engine_client_connector_result_shm(struct ts_engine_client *client, void * const data, size_t len) { struct ts_engine_shm_obj shm; int ret; shm.addr = data; shm.len = len; ret = send_and_receive(client, TS_ENGINE_CONNECTOR_RESULT_SHM, &shm, sizeof(shm)); if (ret < 0) { eng_dbg("send_and_receive failed\n"); return ERROR; } return OK; }
int ts_engine_client_write_profile_shm(struct ts_engine_client *client, char * const data, size_t len) { int ret; struct ts_engine_shm_obj shm; shm.addr = data; shm.len = len; ret = send_and_receive(client, TS_ENGINE_WRITE_PROFILE_SHM, &shm, sizeof(shm)); if (ret < 0) { eng_dbg("send_and_receive failed\n"); return ERROR; } return OK; }
int setup_connection() { int len = 0, ret; ERROR err = NO_ERROR; int comm = KEEP_CONNECTION; int tmp_socket = wpd_connect( port, &err ); if ( err != NO_ERROR ) return -1; len = send_and_receive( tmp_socket, comm, (char*)&ret, &err ); if ( err != NO_ERROR ) { return -1; } if ( ret == -1 ) { close(tmp_socket); return -1; } return tmp_socket; }
static int GetStatus(int card, boardInfo *bi) { RspMessage rcvmsg; int i, status; /* * Fill in some of the basic info about the board */ bi->modelid = sc_adapter[card]->model; strcpy(bi->serial_no, sc_adapter[card]->hwconfig.serial_no); strcpy(bi->part_no, sc_adapter[card]->hwconfig.part_no); bi->iobase = sc_adapter[card]->iobase; bi->rambase = sc_adapter[card]->rambase; bi->irq = sc_adapter[card]->interrupt; bi->ramsize = sc_adapter[card]->hwconfig.ram_size; bi->interface = sc_adapter[card]->hwconfig.st_u_sense; strcpy(bi->load_ver, sc_adapter[card]->load_ver); strcpy(bi->proc_ver, sc_adapter[card]->proc_ver); /* * Get the current PhyStats and LnkStats */ status = send_and_receive(card, CEPID, ceReqTypePhy, ceReqClass2, ceReqPhyStatus, 0, 0, NULL, &rcvmsg, SAR_TIMEOUT); if(!status) { if(sc_adapter[card]->model < PRI_BOARD) { bi->l1_status = rcvmsg.msg_data.byte_array[2]; for(i = 0 ; i < BRI_CHANNELS ; i++) bi->status.bristats[i].phy_stat = rcvmsg.msg_data.byte_array[i]; } else { bi->l1_status = rcvmsg.msg_data.byte_array[0]; bi->l2_status = rcvmsg.msg_data.byte_array[1]; for(i = 0 ; i < PRI_CHANNELS ; i++) bi->status.pristats[i].phy_stat = rcvmsg.msg_data.byte_array[i+2]; } } /* * Get the call types for each channel */ for (i = 0 ; i < sc_adapter[card]->nChannels ; i++) { status = send_and_receive(card, CEPID, ceReqTypeCall, ceReqClass0, ceReqCallGetCallType, 0, 0, NULL, &rcvmsg, SAR_TIMEOUT); if(!status) { if (sc_adapter[card]->model == PRI_BOARD) { bi->status.pristats[i].call_type = rcvmsg.msg_data.byte_array[0]; } else { bi->status.bristats[i].call_type = rcvmsg.msg_data.byte_array[0]; } } } /* * If PRI, get the call states and service states for each channel */ if (sc_adapter[card]->model == PRI_BOARD) { /* * Get the call states */ status = send_and_receive(card, CEPID, ceReqTypeStat, ceReqClass2, ceReqPhyChCallState, 0, 0, NULL, &rcvmsg, SAR_TIMEOUT); if(!status) { for( i = 0 ; i < PRI_CHANNELS ; i++ ) bi->status.pristats[i].call_state = rcvmsg.msg_data.byte_array[i]; } /* * Get the service states */ status = send_and_receive(card, CEPID, ceReqTypeStat, ceReqClass2, ceReqPhyChServState, 0, 0, NULL, &rcvmsg, SAR_TIMEOUT); if(!status) { for( i = 0 ; i < PRI_CHANNELS ; i++ ) bi->status.pristats[i].serv_state = rcvmsg.msg_data.byte_array[i]; } /* * Get the link stats for the channels */ for (i = 1 ; i <= PRI_CHANNELS ; i++) { status = send_and_receive(card, CEPID, ceReqTypeLnk, ceReqClass0, ceReqLnkGetStats, i, 0, NULL, &rcvmsg, SAR_TIMEOUT); if (!status) { bi->status.pristats[i-1].link_stats.tx_good = (unsigned long)rcvmsg.msg_data.byte_array[0]; bi->status.pristats[i-1].link_stats.tx_bad = (unsigned long)rcvmsg.msg_data.byte_array[4]; bi->status.pristats[i-1].link_stats.rx_good = (unsigned long)rcvmsg.msg_data.byte_array[8]; bi->status.pristats[i-1].link_stats.rx_bad = (unsigned long)rcvmsg.msg_data.byte_array[12]; } } /* * Link stats for the D channel */ status = send_and_receive(card, CEPID, ceReqTypeLnk, ceReqClass0, ceReqLnkGetStats, 0, 0, NULL, &rcvmsg, SAR_TIMEOUT); if (!status) { bi->dch_stats.tx_good = (unsigned long)rcvmsg.msg_data.byte_array[0]; bi->dch_stats.tx_bad = (unsigned long)rcvmsg.msg_data.byte_array[4]; bi->dch_stats.rx_good = (unsigned long)rcvmsg.msg_data.byte_array[8]; bi->dch_stats.rx_bad = (unsigned long)rcvmsg.msg_data.byte_array[12]; } return 0; } /* * If BRI or POTS, Get SPID, DN and call types for each channel */ /* * Get the link stats for the channels */ status = send_and_receive(card, CEPID, ceReqTypeLnk, ceReqClass0, ceReqLnkGetStats, 0, 0, NULL, &rcvmsg, SAR_TIMEOUT); if (!status) { bi->dch_stats.tx_good = (unsigned long)rcvmsg.msg_data.byte_array[0]; bi->dch_stats.tx_bad = (unsigned long)rcvmsg.msg_data.byte_array[4]; bi->dch_stats.rx_good = (unsigned long)rcvmsg.msg_data.byte_array[8]; bi->dch_stats.rx_bad = (unsigned long)rcvmsg.msg_data.byte_array[12]; bi->status.bristats[0].link_stats.tx_good = (unsigned long)rcvmsg.msg_data.byte_array[16]; bi->status.bristats[0].link_stats.tx_bad = (unsigned long)rcvmsg.msg_data.byte_array[20]; bi->status.bristats[0].link_stats.rx_good = (unsigned long)rcvmsg.msg_data.byte_array[24]; bi->status.bristats[0].link_stats.rx_bad = (unsigned long)rcvmsg.msg_data.byte_array[28]; bi->status.bristats[1].link_stats.tx_good = (unsigned long)rcvmsg.msg_data.byte_array[32]; bi->status.bristats[1].link_stats.tx_bad = (unsigned long)rcvmsg.msg_data.byte_array[36]; bi->status.bristats[1].link_stats.rx_good = (unsigned long)rcvmsg.msg_data.byte_array[40]; bi->status.bristats[1].link_stats.rx_bad = (unsigned long)rcvmsg.msg_data.byte_array[44]; } /* * Get the SPIDs */ for (i = 0 ; i < BRI_CHANNELS ; i++) { status = send_and_receive(card, CEPID, ceReqTypeCall, ceReqClass0, ceReqCallGetSPID, i+1, 0, NULL, &rcvmsg, SAR_TIMEOUT); if (!status) strcpy(bi->status.bristats[i].spid, rcvmsg.msg_data.byte_array); } /* * Get the DNs */ for (i = 0 ; i < BRI_CHANNELS ; i++) { status = send_and_receive(card, CEPID, ceReqTypeCall, ceReqClass0, ceReqCallGetMyNumber, i+1, 0, NULL, &rcvmsg, SAR_TIMEOUT); if (!status) strcpy(bi->status.bristats[i].dn, rcvmsg.msg_data.byte_array); } return 0; }
/* * Process private IOCTL messages (typically from scctrl) */ int sc_ioctl(int card, scs_ioctl *data) { int status; RspMessage *rcvmsg; char *spid; char *dn; char switchtype; char speed; rcvmsg = kmalloc(sizeof(RspMessage), GFP_KERNEL); if (!rcvmsg) return -ENOMEM; switch(data->command) { case SCIOCRESET: /* Perform a hard reset of the adapter */ { pr_debug("%s: SCIOCRESET: ioctl received\n", sc_adapter[card]->devicename); sc_adapter[card]->StartOnReset = 0; return (reset(card)); } case SCIOCLOAD: { char *srec; srec = kmalloc(SCIOC_SRECSIZE, GFP_KERNEL); if (!srec) { kfree(rcvmsg); return -ENOMEM; } pr_debug("%s: SCIOLOAD: ioctl received\n", sc_adapter[card]->devicename); if(sc_adapter[card]->EngineUp) { pr_debug("%s: SCIOCLOAD: command failed, LoadProc while engine running.\n", sc_adapter[card]->devicename); kfree(rcvmsg); kfree(srec); return -1; } /* * Get the SRec from user space */ if (copy_from_user(srec, data->dataptr, sizeof(srec))) { kfree(rcvmsg); kfree(srec); return -EFAULT; } status = send_and_receive(card, CMPID, cmReqType2, cmReqClass0, cmReqLoadProc, 0, sizeof(srec), srec, rcvmsg, SAR_TIMEOUT); kfree(rcvmsg); kfree(srec); if(status) { pr_debug("%s: SCIOCLOAD: command failed, status = %d\n", sc_adapter[card]->devicename, status); return -1; } else { pr_debug("%s: SCIOCLOAD: command successful\n", sc_adapter[card]->devicename); return 0; } } case SCIOCSTART: { pr_debug("%s: SCIOSTART: ioctl received\n", sc_adapter[card]->devicename); if(sc_adapter[card]->EngineUp) { pr_debug("%s: SCIOCSTART: command failed, engine already running.\n", sc_adapter[card]->devicename); return -1; } sc_adapter[card]->StartOnReset = 1; startproc(card); return 0; } case SCIOCSETSWITCH: { pr_debug("%s: SCIOSETSWITCH: ioctl received\n", sc_adapter[card]->devicename); /* * Get the switch type from user space */ if (copy_from_user(&switchtype, data->dataptr, sizeof(char))) { kfree(rcvmsg); return -EFAULT; } pr_debug("%s: SCIOCSETSWITCH: setting switch type to %d\n", sc_adapter[card]->devicename, switchtype); status = send_and_receive(card, CEPID, ceReqTypeCall, ceReqClass0, ceReqCallSetSwitchType, 0, sizeof(char),&switchtype, rcvmsg, SAR_TIMEOUT); if(!status && !(rcvmsg->rsp_status)) { pr_debug("%s: SCIOCSETSWITCH: command successful\n", sc_adapter[card]->devicename); kfree(rcvmsg); return 0; } else { pr_debug("%s: SCIOCSETSWITCH: command failed (status = %d)\n", sc_adapter[card]->devicename, status); kfree(rcvmsg); return status; } } case SCIOCGETSWITCH: { pr_debug("%s: SCIOGETSWITCH: ioctl received\n", sc_adapter[card]->devicename); /* * Get the switch type from the board */ status = send_and_receive(card, CEPID, ceReqTypeCall, ceReqClass0, ceReqCallGetSwitchType, 0, 0, NULL, rcvmsg, SAR_TIMEOUT); if (!status && !(rcvmsg->rsp_status)) { pr_debug("%s: SCIOCGETSWITCH: command successful\n", sc_adapter[card]->devicename); } else { pr_debug("%s: SCIOCGETSWITCH: command failed (status = %d)\n", sc_adapter[card]->devicename, status); kfree(rcvmsg); return status; } switchtype = rcvmsg->msg_data.byte_array[0]; /* * Package the switch type and send to user space */ if (copy_to_user(data->dataptr, &switchtype, sizeof(char))) { kfree(rcvmsg); return -EFAULT; } kfree(rcvmsg); return 0; } case SCIOCGETSPID: { pr_debug("%s: SCIOGETSPID: ioctl received\n", sc_adapter[card]->devicename); spid = kmalloc(SCIOC_SPIDSIZE, GFP_KERNEL); if(!spid) { kfree(rcvmsg); return -ENOMEM; } /* * Get the spid from the board */ status = send_and_receive(card, CEPID, ceReqTypeCall, ceReqClass0, ceReqCallGetSPID, data->channel, 0, NULL, rcvmsg, SAR_TIMEOUT); if (!status) { pr_debug("%s: SCIOCGETSPID: command successful\n", sc_adapter[card]->devicename); } else { pr_debug("%s: SCIOCGETSPID: command failed (status = %d)\n", sc_adapter[card]->devicename, status); kfree(rcvmsg); return status; } strcpy(spid, rcvmsg->msg_data.byte_array); /* * Package the switch type and send to user space */ if (copy_to_user(data->dataptr, spid, SCIOC_SPIDSIZE)) { kfree(spid); kfree(rcvmsg); return -EFAULT; } kfree(spid); kfree(rcvmsg); return 0; } case SCIOCSETSPID: { pr_debug("%s: DCBIOSETSPID: ioctl received\n", sc_adapter[card]->devicename); spid = kmalloc(SCIOC_SPIDSIZE, GFP_KERNEL); if(!spid) { kfree(rcvmsg); return -ENOMEM; } /* * Get the spid from user space */ if (copy_from_user(spid, data->dataptr, SCIOC_SPIDSIZE)) { kfree(rcvmsg); return -EFAULT; } pr_debug("%s: SCIOCSETSPID: setting channel %d spid to %s\n", sc_adapter[card]->devicename, data->channel, spid); status = send_and_receive(card, CEPID, ceReqTypeCall, ceReqClass0, ceReqCallSetSPID, data->channel, strlen(spid), spid, rcvmsg, SAR_TIMEOUT); if(!status && !(rcvmsg->rsp_status)) { pr_debug("%s: SCIOCSETSPID: command successful\n", sc_adapter[card]->devicename); kfree(rcvmsg); kfree(spid); return 0; } else { pr_debug("%s: SCIOCSETSPID: command failed (status = %d)\n", sc_adapter[card]->devicename, status); kfree(rcvmsg); kfree(spid); return status; } } case SCIOCGETDN: { pr_debug("%s: SCIOGETDN: ioctl received\n", sc_adapter[card]->devicename); /* * Get the dn from the board */ status = send_and_receive(card, CEPID, ceReqTypeCall, ceReqClass0, ceReqCallGetMyNumber, data->channel, 0, NULL, rcvmsg, SAR_TIMEOUT); if (!status) { pr_debug("%s: SCIOCGETDN: command successful\n", sc_adapter[card]->devicename); } else { pr_debug("%s: SCIOCGETDN: command failed (status = %d)\n", sc_adapter[card]->devicename, status); kfree(rcvmsg); return status; } dn = kmalloc(SCIOC_DNSIZE, GFP_KERNEL); if (!dn) { kfree(rcvmsg); return -ENOMEM; } strcpy(dn, rcvmsg->msg_data.byte_array); kfree(rcvmsg); /* * Package the dn and send to user space */ if (copy_to_user(data->dataptr, dn, SCIOC_DNSIZE)) { kfree(dn); return -EFAULT; } kfree(dn); return 0; } case SCIOCSETDN: { pr_debug("%s: SCIOSETDN: ioctl received\n", sc_adapter[card]->devicename); dn = kmalloc(SCIOC_DNSIZE, GFP_KERNEL); if (!dn) { kfree(rcvmsg); return -ENOMEM; } /* * Get the spid from user space */ if (copy_from_user(dn, data->dataptr, SCIOC_DNSIZE)) { kfree(rcvmsg); kfree(dn); return -EFAULT; } pr_debug("%s: SCIOCSETDN: setting channel %d dn to %s\n", sc_adapter[card]->devicename, data->channel, dn); status = send_and_receive(card, CEPID, ceReqTypeCall, ceReqClass0, ceReqCallSetMyNumber, data->channel, strlen(dn),dn,rcvmsg, SAR_TIMEOUT); if(!status && !(rcvmsg->rsp_status)) { pr_debug("%s: SCIOCSETDN: command successful\n", sc_adapter[card]->devicename); kfree(rcvmsg); kfree(dn); return 0; } else { pr_debug("%s: SCIOCSETDN: command failed (status = %d)\n", sc_adapter[card]->devicename, status); kfree(rcvmsg); kfree(dn); return status; } } case SCIOCTRACE: pr_debug("%s: SCIOTRACE: ioctl received\n", sc_adapter[card]->devicename); /* sc_adapter[card]->trace = !sc_adapter[card]->trace; pr_debug("%s: SCIOCTRACE: tracing turned %s\n", sc_adapter[card]->devicename, sc_adapter[card]->trace ? "ON" : "OFF"); */ break; case SCIOCSTAT: { boardInfo *bi; pr_debug("%s: SCIOSTAT: ioctl received\n", sc_adapter[card]->devicename); bi = kmalloc (sizeof(boardInfo), GFP_KERNEL); if (!bi) { kfree(rcvmsg); return -ENOMEM; } kfree(rcvmsg); GetStatus(card, bi); if (copy_to_user(data->dataptr, bi, sizeof(boardInfo))) { kfree(bi); return -EFAULT; } kfree(bi); return 0; } case SCIOCGETSPEED: { pr_debug("%s: SCIOGETSPEED: ioctl received\n", sc_adapter[card]->devicename); /* * Get the speed from the board */ status = send_and_receive(card, CEPID, ceReqTypeCall, ceReqClass0, ceReqCallGetCallType, data->channel, 0, NULL, rcvmsg, SAR_TIMEOUT); if (!status && !(rcvmsg->rsp_status)) { pr_debug("%s: SCIOCGETSPEED: command successful\n", sc_adapter[card]->devicename); } else { pr_debug("%s: SCIOCGETSPEED: command failed (status = %d)\n", sc_adapter[card]->devicename, status); kfree(rcvmsg); return status; } speed = rcvmsg->msg_data.byte_array[0]; kfree(rcvmsg); /* * Package the switch type and send to user space */ if (copy_to_user(data->dataptr, &speed, sizeof(char))) return -EFAULT; return 0; } case SCIOCSETSPEED: pr_debug("%s: SCIOCSETSPEED: ioctl received\n", sc_adapter[card]->devicename); break; case SCIOCLOOPTST: pr_debug("%s: SCIOCLOOPTST: ioctl received\n", sc_adapter[card]->devicename); break; default: kfree(rcvmsg); return -1; } kfree(rcvmsg); return 0; }
/* * Plugin policy check function. * The check_policy function is called by sudo to determine * whether the user is allowed to run the specified commands. */ int policy_check(int argc, char * const argv[], char *env_add[], char **command_info_out[], char **argv_out[], char **user_env_out[]) { char *command; pam_handle_t *pamh; char *pam_user; char *pam_action; int pam_ret = PAM_AUTHTOK_ERR; int sudo_ret = SSS_SUDO_FAILED; struct sudo_result_contents * sudo_result = NULL; if (!argc || argv[0] == NULL) { sudo_log(SUDO_CONV_ERROR_MSG, "no command specified\n"); return FALSE; } command = find_in_path(argv[0], plugin_state.envp); if (command == NULL) { sudo_log(SUDO_CONV_ERROR_MSG, "%s: command not found\n", argv[0]); return FALSE; } /* If "sudo vi" is run, auto-convert to sudoedit. */ if (strcmp(command, _PATH_VI) == 0) use_sudoedit = TRUE; if (use_sudoedit) { /* Rebuild argv using editor */ command = find_editor(argc - 1, argv + 1, argv_out); if (command == NULL) { sudo_log(SUDO_CONV_ERROR_MSG, "unable to find valid editor\n"); return ERROR; } use_sudoedit = TRUE; } else { /* No changes needd to argv */ *argv_out = (char **)argv; } /* No changes to envp */ *user_env_out = plugin_state.envp; /* Space for authentication */ pam_action = strdup("auth"); pam_user = user_information.username; sudo_log(SUDO_CONV_INFO_MSG, "\nCalling PAM with action: %s\nuser: %s\n", pam_action,pam_user); pam_ret = pam_start(SSS_SUDO_PAM_SERVICE, pam_user, &conv, &pamh); if (pam_ret != PAM_SUCCESS) { fprintf(stderr, "pam_start failed: %s\n", pam_strerror(pamh, pam_ret)); return 0; } pam_ret = pam_authenticate(pamh, PAM_DISALLOW_NULL_AUTHTOK); switch(pam_ret) { case PAM_ABORT: fprintf(stderr, "pam_authenticate - aborted: %s\n", pam_strerror(pamh, pam_ret)); pam_end(pamh, pam_ret); return 0; case PAM_AUTH_ERR: fprintf(stderr, "pam_authenticate - error: %s\n", pam_strerror(pamh, pam_ret)); pam_end(pamh, pam_ret); return 0; case PAM_SUCCESS: fprintf(stdout, "pam_authenticate - success: %s\n", pam_strerror(pamh, pam_ret)); break; case PAM_CRED_INSUFFICIENT: fprintf(stderr, "pam_authenticate - crendential not sufficient: %s\n", pam_strerror(pamh, pam_ret)); pam_end(pamh, pam_ret); return 0; case PAM_AUTHINFO_UNAVAIL: fprintf(stderr, "pam_authenticate - authentication information not available: %s\n", pam_strerror(pamh, pam_ret)); pam_end(pamh, pam_ret); return 0; case PAM_USER_UNKNOWN: fprintf(stderr, "pam_authenticate - check the user specified : %s\n", pam_strerror(pamh, pam_ret)); pam_end(pamh, pam_ret); return 0; case PAM_MAXTRIES: fprintf(stderr, "pam_authenticate - maximum tries over : %s\n", pam_strerror(pamh, pam_ret)); pam_end(pamh, pam_ret); return 0; default: fprintf(stderr, "pam_authenticate - unknown error : %s\n", pam_strerror(pamh, pam_ret)); pam_end(pamh, pam_ret); return 0; } /* pam is success :) */ pam_end(pamh, pam_ret); msg.fq_command = command; msg.command = (char **) argv; msg.command_count = argc; if(pam_ret == PAM_SUCCESS) { sudo_ret = send_and_receive(&sudo_result); if(sudo_ret != SSS_SUDO_SUCCESS){ sudo_ret = SSS_SUDO_FAILED; free(pam_action); goto done; } } else{ sudo_ret = SSS_SUDO_FAILED; free(pam_action); goto done; } free(pam_action); /* Setup command info. */ *command_info_out = build_command_info(command); if (*command_info_out == NULL) { sudo_log(SUDO_CONV_ERROR_MSG, "out of memory\n"); return ERROR; } *user_env_out = msg.user_env;/*sudo_result->env_array*/; done: if(sudo_ret==SSS_SUDO_SUCCESS){ free_all(); return SUDO_ALLOW_CMD_EXECUTION; } sudo_log(SUDO_CONV_ERROR_MSG, "User %s is not allowed run command %s on this Host machine( '%s' ) as user %s\n", user_information.username, msg.fq_command, msg.network_addrs, msg.runas_user ); free_all(); return SUDO_DENY_CMD_EXECUTION; }