static void handle_execute_service(void) { int i; int policy_pending_slot; pid_t pid; struct trigger_service_params untrusted_params, params; char remote_domain_id_str[10]; if (libvchan_recv(vchan, &untrusted_params, sizeof(untrusted_params)) < 0) handle_vchan_error("recv params"); /* sanitize start */ ENSURE_NULL_TERMINATED(untrusted_params.service_name); ENSURE_NULL_TERMINATED(untrusted_params.target_domain); ENSURE_NULL_TERMINATED(untrusted_params.request_id.ident); sanitize_name(untrusted_params.service_name, "+"); sanitize_name(untrusted_params.target_domain, "@:"); sanitize_name(untrusted_params.request_id.ident, " "); params = untrusted_params; /* sanitize end */ policy_pending_slot = find_policy_pending_slot(); if (policy_pending_slot < 0) { fprintf(stderr, "Service request denied, too many pending requests\n"); send_service_refused(vchan, &untrusted_params.request_id); return; } switch (pid=fork()) { case -1: perror("fork"); exit(1); case 0: break; default: policy_pending[policy_pending_slot].pid = pid; policy_pending[policy_pending_slot].params = untrusted_params.request_id; return; } for (i = 3; i < MAX_FDS; i++) close(i); signal(SIGCHLD, SIG_DFL); signal(SIGPIPE, SIG_DFL); snprintf(remote_domain_id_str, sizeof(remote_domain_id_str), "%d", remote_domain_id); execl("/usr/bin/qrexec-policy", "qrexec-policy", "--", remote_domain_id_str, remote_domain_name, params.target_domain, params.service_name, params.request_id.ident, NULL); perror("execl"); _exit(1); }
void handle_execute_predefined_command() { int i; struct trigger_connect_params untrusted_params, params; check_children_count_and_wait_if_too_many(); read_all_vchan_ext(&untrusted_params, sizeof(params)); /* sanitize start */ ENSURE_NULL_TERMINATED(untrusted_params.exec_index); ENSURE_NULL_TERMINATED(untrusted_params.target_vmname); ENSURE_NULL_TERMINATED(untrusted_params.process_fds.ident); sanitize_name(untrusted_params.exec_index); sanitize_name(untrusted_params.target_vmname); sanitize_name(untrusted_params.process_fds.ident); params = untrusted_params; /* sanitize end */ switch (fork()) { case -1: perror("fork"); exit(1); case 0: break; default: children_count++; return; } for (i = 3; i < MAX_FDS; i++) close(i); signal(SIGCHLD, SIG_DFL); signal(SIGPIPE, SIG_DFL); execl("/usr/lib/qubes/qrexec_policy", "qrexec_policy", remote_domain_name, params.target_vmname, params.exec_index, params.process_fds.ident, NULL); perror("execl"); exit(1); }
std::string make_material_name(const MObject& src_node) { std::string candidate("Unknown"); if (src_node.hasFn(MFn::kLambert)) { MFnLambertShader shader(src_node); candidate = shader.name().asChar(); } else if (src_node.hasFn(MFn::kBlinn)) { MFnBlinnShader shader(src_node); candidate = shader.name().asChar(); } else if (src_node.hasFn(MFn::kPhong)) { MFnPhongShader shader(src_node); candidate = shader.name().asChar(); } return sanitize_name(candidate); }
/** sanitize Sanitizes a gridlabd model by clear names and position from object headers @returns 0 on success, -2 on error **/ extern "C" int sanitize(int argc, char *argv[]) { OBJECT *obj; FILE *fp; double delta_latitude, delta_longitude; // lat/lon change if ( strcmp(global_sanitizeoffset,"")==0 ) { delta_latitude = random_uniform(NULL,-5,+5); delta_longitude = random_uniform(NULL,-180,+180); } else if ( global_sanitizeoffset=="destroy" ) delta_latitude = delta_longitude = QNAN; else if ( sscanf(global_sanitizeoffset.get_string(),"%lf%*[,/]%lf",&delta_latitude,&delta_longitude)!=2 ) { output_error("sanitize_offset lat/lon '%s' is not valid", global_sanitizeoffset.get_string()); return -2; } // sanitize object names for ( obj=object_get_first() ; obj!=NULL ; obj=object_get_next(obj) ) { if ( obj->name!=NULL && (global_sanitizeoptions&SO_NAMES)==SO_NAMES ) sanitize_name(obj); if ( isfinite(obj->latitude) && (global_sanitizeoptions&SO_GEOCOORDS)==SO_GEOCOORDS ) { obj->latitude += delta_latitude; if ( obj->latitude<-90 ) obj->latitude = -90; if ( obj->latitude>+90 ) obj->latitude = +90; } if ( isfinite(obj->longitude) && (global_sanitizeoptions&SO_GEOCOORDS)==SO_GEOCOORDS ) obj->longitude = fmod(obj->longitude+delta_longitude,360); } // dump object name index if ( strcmp(global_sanitizeindex,".xml")==0 ) { strcpy(global_sanitizeindex,global_modelname); char *ext = strrchr(global_sanitizeindex,'.'); if ( ext && strcmp(ext,".glm")==0 ) strcpy(ext,"-index.xml"); else strcat(global_sanitizeindex,"-index.xml"); } else if ( strcmp(global_sanitizeindex,".txt")==0 ) { strcpy(global_sanitizeindex,global_modelname); char *ext = strrchr(global_sanitizeindex,'.'); if ( ext && strcmp(ext,".glm")==0 ) strcpy(ext,"-index.txt"); else strcat(global_sanitizeindex,"-index.txt"); } else if ( global_sanitizeindex[0]=='.' ) { output_error("sanitization index file spec '%s' is not recognized", global_sanitizeindex.get_string()); return -2; } if ( strcmp(global_sanitizeindex,"")!=0 ) { char *ext = strrchr(global_sanitizeindex,'.'); bool use_xml = (ext && strcmp(ext,".xml")==0) ; fp = fopen(global_sanitizeindex,"w"); if ( fp ) { SAFENAME *item; if ( use_xml ) { fprintf(fp,"<data>\n"); fprintf(fp,"\t<modelname>%s</modelname>\n",global_modelname); fprintf(fp,"\t<geographic_offsets>\n"); fprintf(fp,"\t\t<latitude>%.6f</latitude>\n",delta_latitude); fprintf(fp,"\t\t<longitude>%.6f</longitude>\n",delta_longitude); fprintf(fp,"\t</geographic_offsets>\n"); fprintf(fp,"\t<safename_list>\n"); for ( item=safename_list ; item!=NULL ; item=item->next ) fprintf(fp,"\t\t<name>\n\t\t\t<safe>%s</safe>\n\t\t\t<unsafe>%s</unsafe>\n\t\t</name>\n", item->name, item->old); fprintf(fp,"\t</safename_list>\n"); fprintf(fp,"</data>\n"); } else { fprintf(fp,"modelname\t= %s\n", global_modelname); fprintf(fp,"\n[POSITIONS]\n"); fprintf(fp,"latitude\t= %.6f\n",delta_latitude); fprintf(fp,"longitude\t= %.6f\n",delta_longitude); fprintf(fp,"\n[NAMES]\n"); for ( item=safename_list ; item!=NULL ; item=item->next ) fprintf(fp,"%s\t= %s\n", item->name, item->old); } fclose(fp); } } return 0; }
std::string sanitize_name(std::string name, const std::vector<std::string>& brethren) { sanitize_name(name); bool is_here = false; ossia::optional<int> name_instance; ossia::small_vector<int, 16> instance_num; instance_num.reserve(brethren.size()); // First get the root name : the first part of the "a.b" std::string root_name = name; { auto pos = name.find_last_of('.'); if (pos != std::string::npos) { try { name_instance = boost::lexical_cast<int>(name.substr(pos + 1)); // OPTIMIZEME root_name = name.substr(0, pos); } catch (...) { } } } const auto root_len = root_name.size(); for (const std::string& n_name : brethren) { if (n_name == name) { is_here = true; } if (n_name.size() < (root_len + 1)) continue; bool same_root = (n_name.compare(0, root_len, root_name) == 0); if (same_root && (n_name[root_len] == '.')) { // Instance try { int n = boost::lexical_cast<int>( n_name.substr(root_len + 1)); // OPTIMIZEME instance_num.push_back(n); } catch (...) { continue; } } // case where we have the "default" instance without .0 else if (same_root && root_len == n_name.length()) { instance_num.push_back(0); } } if (!is_here) { return name; } else { auto n = instance_num.size(); if ((n == 0) || ((n == 1) && (instance_num[0] == 0))) { return root_name + ".1"; } else { std::sort(instance_num.begin(), instance_num.end()); return root_name + "." + boost::lexical_cast<std::string>(instance_num.back() + 1); } } }
void sanitize_name( std::string& name, const ossia::net::node_base::children_t& brethren) { sanitize_name(name); bool is_here = false; ossia::optional<int> name_instance; ossia::small_vector<int, 16> instance_num; instance_num.reserve(brethren.size()); // First get the root name : the first part of the "a.b" std::string root_name = name; { auto pos = name.find_last_of('.'); if (pos != std::string::npos) { int n{}; if(boost::conversion::detail::try_lexical_convert(name.substr(pos + 1), n)) { // OPTIMIZEME name_instance = n; root_name = name.substr(0, pos); } } } const auto root_len = root_name.size(); for (const auto& bro : brethren) { const auto& n_name = bro->get_name(); if (n_name == name) { is_here = true; } if (n_name.size() < (root_len + 1)) continue; bool same_root = (n_name.compare(0, root_len, root_name) == 0); if (same_root && (n_name[root_len] == '.')) { // Instance int n{}; // OPTIMIZEME if(boost::conversion::detail::try_lexical_convert(n_name.substr(root_len + 1), n)) { instance_num.push_back(n); } } // case where we have the "default" instance without .0 else if (same_root && root_len == n_name.length()) { instance_num.push_back(0); } } if (!is_here) { return; } else { auto n = instance_num.size(); if ((n == 0) || ((n == 1) && (instance_num[0] == 0))) { name = root_name; name += ".1"; } else { std::sort(instance_num.begin(), instance_num.end()); name = root_name; name += '.'; name += boost::lexical_cast<std::string>(instance_num.back() + 1); } } }
static void mat_write_signal(const mdf_t *const mdf, const uint32_t can_channel, const uint32_t number_of_records, const uint16_t channel_type, const char *const message_name, const char *const signal_name, const double *const timeValue, const filter_t *const filter, const void *const cbData) { char *filter_signal_name_in; char *filter_message_name_in; char *filter_name_out; size_t dims[2]; mdftomat_t *const mdftomat = (mdftomat_t *)cbData; dims[0] = number_of_records; dims[1] = 2; if( ((can_channel != 0) && (channel_type == 0)) /* Vector CAN */ || ((can_channel == 0) && (channel_type == 0)) /* DIM */ ) { if(mdf->verbose_level >= 2) { uint32_t ir; printf("ch=%lu n=%lu m=%s s=%s\n", (unsigned long)can_channel, (unsigned long)number_of_records, message_name, signal_name); if(mdf->verbose_level >= 3) { for(ir=0;ir<number_of_records;ir++) { printf("%g %g\n",timeValue[ir],timeValue[ir+number_of_records]); } } } /* sanitize variable name */ filter_signal_name_in = sanitize_name(signal_name); filter_message_name_in = sanitize_name(message_name); filter_name_out = filter_apply(filter, can_channel, filter_message_name_in, filter_signal_name_in); if(mdf->verbose_level >= 2) { printf(" CNBLOCK can_ch=%lu\n" " message = %s\n" " signal_name = %s\n" " filter_input = %s\n" " filter_output= %s\n", (unsigned long)can_channel, filter_message_name_in, signal_name, filter_signal_name_in, (filter_name_out!=NULL)?filter_name_out:"<rejected by filter>" ); if(filter_name_out != NULL) { printf("+ %d %s %s %s\n", can_channel, filter_message_name_in, filter_signal_name_in, filter_name_out ); } } free(filter_signal_name_in); free(filter_message_name_in); if(filter_name_out != NULL) { matvar_t *matvar; int rv; /* write matlab variable */ matvar = Mat_VarCreate(filter_name_out, MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, (double *)timeValue, 0); rv = Mat_VarWrite(mdftomat->mat, matvar, mdftomat->compress); assert(rv == 0); Mat_VarFree(matvar); free(filter_name_out); } } }
ssize_t read_chos_file(char *user_conf_file, char *dir, char *osenv) { int conf; int i; ssize_t count = 0; int ret; char userfile[MAX_LEN+1]; /* Build the full path to the user configuration file. */ ret = snprintf(userfile,MAX_LEN+1,"%.100s/%.20s",dir,user_conf_file); if (ret < 1) { syslog(LOG_ERR, "Could not construct path to user configuration file.\n"); return -1; } else if (ret > MAX_LEN+1) { syslog(LOG_ERR, "Path to user configuration file is too long.\n"); return -1; } /* * Open the user configuration file and read the contents into * osenv. osenv must have at least MAXLINE+1 of space available. * * If no bytes or read or the configuration file cannot be opened, * write the default environment name instead. */ conf=open(userfile,O_RDONLY); if (conf >= 0) { /* Read environment name from user configuration file. */ count=read(conf,osenv,MAXLINE); if (count == 0) { /* EOF was received and no bytes were read. Log a warning and * continue. */ syslog(LOG_WARNING, "Warning: Read 0 bytes from user configuration file (%s)\n", userfile); } else if (count < 0) { /* read() returned an error. Log a warning and confinue. */ syslog(LOG_WARNING, "Warning: failed to read() user configuration file (%s): %s\n", userfile, strerror(errno)); count = 0; } /* Explicitly set osenv[count] to the null byte. On error or EOF, * this sets osenv[0] to '\0'. On successful reads, it ensures * the string is null-terminated. */ osenv[count] = '\0'; if (close(conf) != 0) { syslog(LOG_WARNING, "Could not close() user configuration file (%s): %s\n", userfile, strerror(errno)); return(-1); } } else if(errno != ENOENT) { /* The user configuration file could not be opened. Log a warning * if open() failed for a reason other than ENOENT, and continue. */ syslog(LOG_WARNING, "Warning: Could not open user configuration file (%s): %s\n", userfile, strerror(errno)); } if (count == 0) { /* If no bytes were read, then set osenv to the default * environment name. */ snprintf(osenv, MAXLINE+1, "%s", DEFAULT_ENV_NAME); count=strlen(osenv) + 1; } for (i = 0; i < count; i++) { if ((osenv[i]=='\n') || (osenv[i]=='\0') ) break; } osenv[i]=0; sanitize_name(osenv,strlen(osenv)); return count; }
int get_chos_info(int argc, const char **argv, int fd, char *user_conf_dir) { char osenv[MAXLINE+1]; char *os; const char *env; FILE *f; pam_chos_config cfg; if(!(init_pam_chos_config(&cfg))) { syslog(LOG_ERR, "Failed to initialize configuration\n"); return -1; } if(parse_pam_chos_args(&cfg, argc, argv) != 1) { syslog(LOG_ERR, "Failed to parse configuration\n"); return -1; } if( (read_chos_file(cfg.user_conf_file, user_conf_dir, osenv)) < 0) { syslog(LOG_ERR, "Error while handling user configuration file\n"); return -1; } /* If $CHOS is set, use its value as the OS name. */ if ((env=getenv("CHOS"))) { if ( strlen(env) > MAXLINE ) { syslog(LOG_WARNING, "Warning: $CHOS value is too long, ignoring\n"); } else { strncpy(osenv,env,MAXLINE+1); sanitize_name(osenv, strlen(osenv)); } } /* * Attempt to retrieve the environment path from the environment * name. * */ os=check_chos(osenv); if (os == NULL) { /* We were unable to match the environment name against a valid * environment path. */ if ( (strcmp(osenv,DEFAULT_ENV_NAME)==0) || (cfg.fail_to_default > 0) ) { /* If the environment name is "default", or fail_to_default==1, * then fail back to the default environment. */ syslog(LOG_WARNING, "Warning: requested os (%s) is not recognized; using default (fail_to_default=%d).\n", osenv, cfg.fail_to_default); os=check_chos(DEFAULT_ENV_NAME); } else { /* Try the (likely invalid) environment name. */ syslog(LOG_WARNING, "Warning: requested os (%s) is not recognized.\n",osenv); os=osenv; } } /* Write the environment name and path to fd */ f = fdopen(fd,"w"); if(!f) { syslog(LOG_ERR, "fdopen() failed: %s\n",strerror(errno)); return -1; } /* Write the os path and name to the file. */ fputs(os,f); fputc('\n',f); fputs(osenv,f); fputc('\n',f); /* We are done writing to the pipe, so we can close it now. */ if(fclose(f) != 0) { syslog(LOG_ERR, "fclose() failed: %s\n",strerror(errno)); return -1; } return 1; }