void my_set_env(t_mysh *mysh) { char *param_in_env; int i; i = 0; while (mysh->tab_com[i]) i++; if (comp_str(mysh->tab_com[0], "setenv") == 1 && mysh->tab_com[1] && i < 4) { if ((param_in_env = src_env(mysh->env, mysh->tab_com[1]))) update_env(mysh); else add_env(mysh); if (param_in_env) free (param_in_env); } else if (comp_str(mysh->tab_com[0], "setenv") == 1 && i == 1) { i = -1; while (mysh->env && mysh->env[++i]) my_printf("%s\n", mysh->env[i]); } else if (comp_str(mysh->tab_com[0], "setenv") == 1 && i >= 4) my_error("setenv: Too many arguments.\n"); }
struct Node *insert_node(struct Node *tree, struct Node *node) { struct Node *tmp=tree; struct Node *next=NULL; if (tree==NULL) return node; next=comp_str(node->id,tmp->id,tmp); while (NULL!= next) { tmp=next; next=comp_str(node->id,tmp->id,tmp); }; if (strcmp(node->id,tmp->id)>0) tmp->right=node; else tmp->left=node; return tree; }
void my_cd(t_mysh *mysh) { int ret; char *pwd; pwd = my_strdup("OLDPWD="); pwd = my_strcat_free(pwd, getcwd(NULL, 1000)); /* getcwd a free*/ ret = 0; if (comp_str(mysh->tab_com[0], "cd") == 1) { if (mysh->tab_com[1] && mysh->tab_com[1][0] == '-') ret = chdir(src_env(mysh->env, "OLDPWD")); else if (!mysh->tab_com[1]) ret = chdir(src_env(mysh->env, "HOME")); else ret = chdir(mysh->tab_com[1]); if (ret == -1) { my_error("cd: no such file or directory: "); my_error(mysh->tab_com[1]); my_error("\n"); } else update_pwd(mysh, pwd); } free (pwd); }
void exec_multi_command(t_mysh *mysh, char *com) { if (com) { mysh->tab_com = get_command(com); if (comp_str(com, "<<") || comp_str(com, ">>") || comp_str(com, "<") || comp_str(com, ">") || comp_str(com, "|")) { my_putstr("Ambiguous output redirect.\n"); clean_mem(mysh); exit(42); } my_builtins(mysh); exec_command(mysh); } else clean_mem(mysh); }
void my_exit(t_mysh *mysh) { int exite; exite = (mysh->tab_com[1]) ? check_str(mysh->tab_com[1]) : 0; if (comp_str(mysh->tab_com[0], "exit") == 1) { if (aff_prompt() == 1) my_putstr("exit\n"); free_command(mysh); free_struct(mysh); exit(exite); } }
void put_in_stdin_dd_redir_left(char *com, int fd, t_com *elem) { char **tab; char *tmp; tab = get_command(com); my_putstr("? "); while ((tmp = get_next_line(0)) && comp_str(tmp, tab[0]) == 0) { my_write(fd, tmp, my_strlen(tmp)); my_write(fd, "\n", 1); free(tmp); my_putstr("? "); } free_tab(tab); tmp = my_strdup(elem->com); free(elem->com); elem->com = my_strdup(elem->prev->prev->com); free(elem->prev->prev->com); elem->prev->prev->com = my_strdup(tmp); free(tmp); }
/*! \brief eval_elem helping function, returns an op param */ inline static int comp_ip(struct sip_msg *msg, int op, struct ip_addr* ip, operand_t *opd) { struct hostent* he; char ** h; int ret; str tmp; ret=-1; switch(opd->type){ case NET_ST: switch(op){ case EQUAL_OP: ret=(matchnet(ip, (struct net*)opd->v.data)==1); break; case DIFF_OP: ret=(matchnet(ip, (struct net*)opd->v.data)!=1); break; default: goto error_op; } break; case STR_ST: case RE_ST: switch(op){ case EQUAL_OP: case MATCH_OP: /* 1: compare with ip2str*/ ret=comp_str(ip_addr2a(ip), opd->v.data, op, opd->type); if (ret==1) break; /* 2: resolve (name) & compare w/ all the ips */ if (opd->type==STR_ST){ he=resolvehost((char*)opd->v.data,0); if (he==0){ LM_DBG("could not resolve %s\n",(char*)opd->v.data); }else if (he->h_addrtype==(int)ip->af){ for(h=he->h_addr_list;(ret!=1)&& (*h); h++){ ret=(memcmp(ip->u.addr, *h, ip->len)==0); } if (ret==1) break; } } /* 3: (slow) rev dns the address * and compare with all the aliases * !!??!! review: remove this? */ if(received_dns & DO_REV_DNS) { he=rev_resolvehost(ip); if (he==0){ print_ip("comp_ip: could not rev_resolve ip" " address: ", ip, "\n"); ret=0; }else{ /* compare with primary host name */ ret=comp_str(he->h_name, opd->v.data, op, opd->type); /* compare with all the aliases */ for(h=he->h_aliases; (ret!=1) && (*h); h++){ ret=comp_str(*h, opd->v.data, op, opd->type); } } } else { return 0; } break; case DIFF_OP: ret=comp_ip(msg, op, ip, opd); if (ret>=0) ret=!ret; break; default: goto error_op; } break; case MYSELF_ST: /* check if it's one of our addresses*/ tmp.s=ip_addr2a(ip); tmp.len=strlen(tmp.s); ret=check_self_op(op, &tmp, 0); break; default: LM_CRIT("invalid type for src_ip or dst_ip (%d)\n", opd->type); ret=-1; } return ret; error_op: LM_CRIT("invalid operator %d\n", op); return -1; }
/* eval_elem helping function, returns an op param */ inline static int comp_ip(struct ip_addr* ip, void* param, int op, int subtype) { struct hostent* he; char ** h; int ret; str tmp; ret=-1; switch(subtype){ case NET_ST: switch(op){ case EQUAL_OP: ret=(matchnet(ip, (struct net*) param)==1); break; case DIFF_OP: ret=(matchnet(ip, (struct net*) param)!=1); break; default: goto error_op; } break; case STRING_ST: case RE_ST: switch(op){ case EQUAL_OP: case MATCH_OP: /* 1: compare with ip2str*/ ret=comp_str(ip_addr2a(ip), param, op, subtype); if (ret==1) break; /* 2: resolve (name) & compare w/ all the ips */ if (subtype==STRING_ST){ he=resolvehost((char*)param); if (he==0){ DBG("comp_ip: could not resolve %s\n", (char*)param); }else if (he->h_addrtype==ip->af){ for(h=he->h_addr_list;(ret!=1)&& (*h); h++){ ret=(memcmp(ip->u.addr, *h, ip->len)==0); } if (ret==1) break; } } /* 3: (slow) rev dns the address * and compare with all the aliases * !!??!! review: remove this? */ he=rev_resolvehost(ip); if (he==0){ print_ip( "comp_ip: could not rev_resolve ip address:" " ", ip, "\n"); ret=0; }else{ /* compare with primary host name */ ret=comp_str(he->h_name, param, op, subtype); /* compare with all the aliases */ for(h=he->h_aliases; (ret!=1) && (*h); h++){ ret=comp_str(*h, param, op, subtype); } } break; case DIFF_OP: ret=comp_ip(ip, param, EQUAL_OP, subtype); if (ret>=0) ret=!ret; break; default: goto error_op; } break; case MYSELF_ST: /* check if it's one of our addresses*/ tmp.s=ip_addr2a(ip); tmp.len=strlen(tmp.s); ret=check_self_op(op, &tmp, 0); break; default: LOG(L_CRIT, "BUG: comp_ip: invalid type for " " src_ip or dst_ip (%d)\n", subtype); ret=-1; } return ret; error_op: LOG(L_CRIT, "BUG: comp_ip: invalid operator %d\n", op); return -1; }
ShapeParser::ShapeParseResult ShapeParser::serialized(const XMLNode& node, ParserState& S) { auto filename = S.map_asset_filepath(S.def_storage.prop_string(node, "filename")); int submesh_index = S.def_storage.prop_int(node, "shapeIndex"); bool flipNormals = S.def_storage.prop_bool(node, "flipNormals", false); bool faceNormals = S.def_storage.prop_bool(node, "faceNormals", false); float maxSmoothAngle = S.def_storage.prop_float(node, "maxSmoothAngle", 0.0f); auto name = boost::filesystem::path(filename).stem().string(); auto compiled_tar_folder = S.scene.getFileManager()->getCompiledMeshPath("") + name + "/"; auto get_compiled_submesh_filename = [&](size_t i) { return compiled_tar_folder + std::to_string(i) + ".xmsh"; }; if (!boost::filesystem::exists(compiled_tar_folder) || !boost::filesystem::exists(get_compiled_submesh_filename(0))) { boost::filesystem::create_directory(compiled_tar_folder); enum DataPresentFlag : uint32_t { VertexNormals = 0x0001, TextureCoords = 0x0002, VertexColors = 0x0008, UseFaceNormals = 0x0010, SinglePrecision = 0x1000, DoublePrecision = 0x2000, }; struct inflateStream { std::ifstream& m_childStream; size_t str_length; z_stream m_inflateStream; uint8_t m_inflateBuffer[32768]; inflateStream(std::ifstream& str) :m_childStream(str) { size_t pos = m_childStream.tellg(); m_childStream.seekg(0, m_childStream.end); str_length = m_childStream.tellg(); m_childStream.seekg(pos, m_childStream.beg); m_inflateStream.zalloc = Z_NULL; m_inflateStream.zfree = Z_NULL; m_inflateStream.opaque = Z_NULL; m_inflateStream.avail_in = 0; m_inflateStream.next_in = Z_NULL; int windowBits = 15; auto retval = inflateInit2(&m_inflateStream, windowBits); if (retval != Z_OK) std::cout << "erro, ret : " << retval << std::endl; } void read(void *ptr, size_t size) { uint8_t *targetPtr = (uint8_t *)ptr; while (size > 0) { if (m_inflateStream.avail_in == 0) { size_t remaining = str_length - m_childStream.tellg(); m_inflateStream.next_in = m_inflateBuffer; m_inflateStream.avail_in = (uInt)std::min(remaining, sizeof(m_inflateBuffer)); if (m_inflateStream.avail_in == 0) std::cout << "more bytes req : " << size << std::endl; m_childStream.read((char*)m_inflateBuffer, m_inflateStream.avail_in); } m_inflateStream.avail_out = (uInt)size; m_inflateStream.next_out = targetPtr; int retval = inflate(&m_inflateStream, Z_NO_FLUSH); switch (retval) { case Z_STREAM_ERROR: throw std::runtime_error("inflate(): stream error!"); case Z_NEED_DICT: throw std::runtime_error("inflate(): need dictionary!"); case Z_DATA_ERROR: throw std::runtime_error("inflate(): data error!"); case Z_MEM_ERROR: throw std::runtime_error("inflate(): memory error!"); }; size_t outputSize = size - (size_t)m_inflateStream.avail_out; targetPtr += outputSize; size -= outputSize; if (size > 0 && retval == Z_STREAM_END) throw std::runtime_error("inflate(): attempting to read past the end of the stream!"); } } }; std::ifstream ser_str(filename, std::ios::binary); uint16_t magic_maj, version_maj; ser_str.read((char*)&magic_maj, 2); if (magic_maj != 1052) throw std::runtime_error("corrupt file"); ser_str.read((char*)&version_maj, 2); ser_str.seekg(-4, ser_str.end); uint32_t n_meshes; ser_str.read((char*)&n_meshes, sizeof(n_meshes)); ser_str.seekg(-(sizeof(uint32_t) + (version_maj == 4 ? sizeof(uint64_t) : sizeof(uint32_t)) * n_meshes), ser_str.end); std::vector<uint64_t> mesh_offsets(n_meshes); if (version_maj == 4) ser_str.read((char*)mesh_offsets.data(), n_meshes * sizeof(uint64_t)); else { auto q = std::vector<uint32_t>(n_meshes); ser_str.read((char*)q.data(), n_meshes * sizeof(uint32_t)); for (size_t i = 0; i < n_meshes; i++) mesh_offsets[i] = q[i]; } for (size_t num_submesh = 0; num_submesh < n_meshes; num_submesh++) { ser_str.seekg(mesh_offsets[num_submesh], ser_str.beg); uint16_t magic, version; ser_str.read((char*)&magic, 2); if (magic == 0) break; ser_str.read((char*)&version, 2); if (version != 3 && version != 4) throw std::runtime_error("invalid version in serialized mesh file"); inflateStream comp_str(ser_str); DataPresentFlag flag; comp_str.read(&flag, sizeof(flag)); std::string name = "default"; if (version == 4) { name = ""; char last_read; do { comp_str.read(&last_read, sizeof(last_read)); name += last_read; } while (last_read != 0); } uint64_t nVertices, nTriangles; comp_str.read(&nVertices, sizeof(nVertices)); comp_str.read(&nTriangles, sizeof(nTriangles)); std::vector<Vec3f> positions(nVertices), normals(nVertices), colors(nVertices); std::vector<Vec2f> uvcoords(nVertices); std::vector<uint32_t> indices(nTriangles * 3); bool isSingle = true; auto read_n_vector = [&](int dim, float* buffer) { if (isSingle) comp_str.read((char*)buffer, sizeof(float) * dim * nVertices); else { double* double_storage = (double*)alloca(dim * sizeof(double)); for (size_t i = 0; i < nVertices; i++) { comp_str.read((char*)double_storage, dim * sizeof(double)); for (int j = 0; j < dim; j++) buffer[i * dim + j] = float(double_storage[j]); } } }; read_n_vector(3, (float*)positions.data()); if ((flag & DataPresentFlag::VertexNormals) == DataPresentFlag::VertexNormals) read_n_vector(3, (float*)normals.data()); if ((flag & DataPresentFlag::TextureCoords) == DataPresentFlag::TextureCoords) read_n_vector(2, (float*)uvcoords.data()); else std::fill(uvcoords.begin(), uvcoords.end(), Vec2f(0.0f)); if ((flag & DataPresentFlag::VertexColors) == DataPresentFlag::VertexColors) read_n_vector(3, (float*)colors.data()); comp_str.read((char*)indices.data(), sizeof(uint32_t) * nTriangles * 3); for (size_t i = 0; i < nTriangles * 3; i += 3) std::swap(indices[i + 0], indices[i + 2]); auto compiled_submesh_filename = get_compiled_submesh_filename(num_submesh); FileOutputStream fOut(compiled_submesh_filename); fOut << (unsigned int)MeshCompileType::Static; auto mat = Material(name.size() > 60 ? name.substr(0, 60) : name); mat.bsdf = CreateAggregate<BSDFALL>(diffuse()); Mesh::CompileMesh(positions.data(), (int)positions.size(), normals.data(), uvcoords.data(), indices.data(), (int)indices.size(), mat, 0.0f, fOut, flipNormals, faceNormals, maxSmoothAngle); fOut.Close(); } ser_str.close(); } auto obj = S.scene.CreateNode(get_compiled_submesh_filename(submesh_index)); parseGeneric(obj, node, S); return obj; }
int commands(void *arg) { char *p = NULL; char c[500]; sbool running = TRUE; p = c; puts("Type /help for a list of commands"); reloop: while(running){ if(gets(p)){ switch(*p){ case '/': { switch(*(++p)){ case 's': { if(comp_str(p, "setgroup")){ char user[MAX_NAME_LENGTH]; int i = 0; uint16 user_id = 0; int group; p += 8; //move to name. while(*p){ if(i > MAX_NAME_LENGTH){ puts("Invalid User Name"); goto reloop; } user[i] = *(++p); if(user[i] == ' '){ user[i] = '\0'; break; } i++; } switch(*(++p)){ case '0': group = GROUP_USER; break; case '1': group = GROUP_MONITOR; break; case '2': group = GROUP_MAPPER; break; case '3': group = GROUP_DEVELOPER; break; case '4': group = GROUP_CREATOR; break; default: goto reloop; } user_id = find_player(user); if(user_id > -1){ player(user_id)->group = group; puts("Group was changed"); } else puts("User Not Found"); break; } if( comp_str(++p, "hutdown")){ set_shut_down(); } break; } case 'c': if( comp_str(++p, "lose")){ set_server_offline(); return 0; } break; case 'h': if( comp_str(++p, "elp")){ puts("::::Server Commands::::"); puts("/close: Instant shutdown of server."); puts("/shutdown: Timed shutdown of server."); puts("/setgroup username groupid: Sets a players group via server."); } break; default: puts("Invalid command, Type /help for a list of commands"); break; } break; } default: puts("invalid command, type /help for a list of commands"); break; } } } return 0; }