static void readVertices(spSkeletonBinary *self, spVertexAttachment *attachment, int vertexCount) { if (!readBoolean(self)) { attachment->vertices = readFloats(self, self->scale, vertexCount << 1); attachment->verticesCount = vertexCount << 1; attachment->bones = NULL; attachment->bonesCount = 0; } else { float *weights; int *bones; int weightCount = 0, boneCount = 0; int position = self->data->position; for (int i = 0; i < vertexCount; i++) { int nn = readVarint(self, true); boneCount++; for (int ii = 0; ii < nn; ii++) { readVarint(self, true); self->data->position += sizeof(float) * 3; weightCount += 3; boneCount++; } } self->data->position = position; attachment->bones = MALLOC(int, boneCount); attachment->bonesCount = boneCount; attachment->vertices = MALLOC(float, weightCount); attachment->verticesCount = weightCount; weights = attachment->vertices; bones = attachment->bones; for (int i = 0; i < vertexCount; i++) { int nn = readVarint(self, true); *bones++ = nn; for (int ii = 0; ii < nn; ii++) { *bones++ = readVarint(self, true); *weights++ = readFloat(self) * self->scale; *weights++ = readFloat(self) * self->scale; *weights++ = readFloat(self); } } } }
uint32_t Node::decode(const std::vector<uint8_t>& buffer, uint32_t offset) { uint32_t originalOffset = offset; if (buffer.size() - offset < 1) { return 0; } marker = *reinterpret_cast<const Marker*>(buffer.data() + offset); offset += 1; uint32_t ret = 0; switch (marker) { case Marker::Number: ret = readNumber(buffer, offset, doubleValue); break; case Marker::Boolean: ret = readBoolean(buffer, offset, boolValue); break; case Marker::String: ret = readString(buffer, offset, stringValue); break; case Marker::Object: ret = readObject(buffer, offset, mapValue); break; case Marker::Null: /* Null */; break; case Marker::Undefined: /* Undefined */; break; case Marker::ECMAArray: ret = readECMAArray(buffer, offset, mapValue); break; case Marker::ObjectEnd: break; // should not happen case Marker::StrictArray: ret = readStrictArray(buffer, offset, vectorValue); break; case Marker::Date: ret = readDate(buffer, offset, dateValue); break; case Marker::LongString: ret = readLongString(buffer, offset, stringValue); break; case Marker::XMLDocument: ret = readXMLDocument(buffer, offset, stringValue); break; case Marker::TypedObject: ret = readTypedObject(buffer, offset); break; case Marker::SwitchToAMF3: ret = readSwitchToAMF3(buffer, offset); break; default: return 0; } offset += ret; return offset - originalOffset; }
static int readConfigOption( INOUT STREAM *stream, IN_HANDLE CRYPT_USER iCryptUser ) { CRYPT_ATTRIBUTE_TYPE attributeType; const BUILTIN_OPTION_INFO *builtinOptionInfoPtr; MESSAGE_DATA msgData; void *dataPtr DUMMY_INIT_PTR; long optionCode; int value, tag, length, status; /* Read the wrapper and option index and map it to the actual option. If we find an unknown index or one that shouldn't be writeable to persistent storage, we skip it and continue. This is done to handle new options that may have been added after this version of cryptlib was built (for unknown indices) and because the stored configuration options are an untrusted source so we have to check for attempts to feed in bogus values (for non-writeable options) */ readSequence( stream, NULL ); status = readShortInteger( stream, &optionCode ); if( cryptStatusError( status ) ) return( status ); if( optionCode < 0 || optionCode > LAST_OPTION_INDEX ) { /* Unknown option, ignore it */ return( readUniversal( stream ) ); } builtinOptionInfoPtr = getBuiltinOptionInfoByCode( optionCode ); if( builtinOptionInfoPtr == NULL || \ builtinOptionInfoPtr->index < 0 || \ builtinOptionInfoPtr->index > LAST_OPTION_INDEX || \ builtinOptionInfoPtr->index == CRYPT_UNUSED ) { /* Unknown option, ignore it */ return( readUniversal( stream ) ); } attributeType = builtinOptionInfoPtr->option; /* Read the option value and set the option. We don't treat a failure to set the option as a problem since the user probably doesn't want the entire system to fail because of a bad configuration option, and in any case we'll fall back to a safe default value */ status = tag = peekTag( stream ); if( cryptStatusError( status ) ) return( status ); if( tag == BER_BOOLEAN || tag == BER_INTEGER ) { /* It's a numeric value, read the appropriate type and try and set the option */ if( tag == BER_BOOLEAN ) status = readBoolean( stream, &value ); else { long integer; status = readShortInteger( stream, &integer ); if( cryptStatusOK( status ) ) value = ( int ) integer; } if( cryptStatusError( status ) ) return( status ); ( void ) krnlSendMessage( iCryptUser, IMESSAGE_SETATTRIBUTE, &value, attributeType ); return( CRYPT_OK ); } /* It's a string value, set the option straight from the encoded data */ status = readGenericHole( stream, &length, 1, BER_STRING_UTF8 ); if( cryptStatusOK( status ) ) status = sMemGetDataBlock( stream, &dataPtr, length ); if( cryptStatusOK( status ) ) status = sSkip( stream, length, SSKIP_MAX ); if( cryptStatusError( status ) ) return( status ); setMessageData( &msgData, dataPtr, length ); ( void ) krnlSendMessage( iCryptUser, IMESSAGE_SETATTRIBUTE_S, &msgData, attributeType ); return( CRYPT_OK ); }
void ObjectDataInput::readInternal(int typeId, bool *object) { *object = readBoolean(); }
static spAttachment *readAttachment(spSkeletonBinary *self, spSkin *skin, int slotIndex, const char *attachmentName) { spAttachment *attachment = NULL; float scale = self->scale; char *name = readString(self); if (name == NULL) name = (char *)attachmentName; switch ((spAttachmentType)readByte(self)) { case SP_ATTACHMENT_REGION: { spRegionAttachment *region; char *path = readString(self); if (path == NULL) path = name; attachment = spAttachmentLoader_createAttachment(self->attachmentLoader, skin, SP_ATTACHMENT_REGION, name, path); region = SUB_CAST(spRegionAttachment, attachment); if (path) { region->path = copyString(path); } region->rotation = readFloat(self); region->x = readFloat(self) * scale; region->y = readFloat(self) * scale; region->scaleX = readFloat(self); region->scaleY = readFloat(self); region->width = readFloat(self) * scale; region->height = readFloat(self) * scale; readColor(self, ®ion->r, ®ion->g, ®ion->b, ®ion->a); spRegionAttachment_updateOffset(region); spAttachmentLoader_configureAttachment(self->attachmentLoader, attachment); break; } case SP_ATTACHMENT_BOUNDING_BOX: { spBoundingBoxAttachment *boundingBox; int vertexCount = readVarint(self, true); attachment = spAttachmentLoader_createAttachment(self->attachmentLoader, skin, SP_ATTACHMENT_BOUNDING_BOX, name, name); boundingBox = SUB_CAST(spBoundingBoxAttachment, attachment); readVertices(self, SUPER(boundingBox), vertexCount); SUPER(boundingBox)->worldVerticesLength = vertexCount << 1; spAttachmentLoader_configureAttachment(self->attachmentLoader, attachment); break; } case SP_ATTACHMENT_MESH: { spMeshAttachment *mesh; int vertexCount; char *path = readString(self); if (path == NULL) path = name; attachment = spAttachmentLoader_createAttachment(self->attachmentLoader, skin, SP_ATTACHMENT_MESH, name, path); mesh = SUB_CAST(spMeshAttachment, attachment); if (path) { mesh->path = copyString(path); } readColor(self, &mesh->r, &mesh->g, &mesh->b, &mesh->a); vertexCount = readVarint(self, true); mesh->regionUVs = readFloats(self, 1, vertexCount << 1); mesh->trianglesCount = readVarint(self, true); mesh->triangles = readShorts(self, mesh->trianglesCount); readVertices(self, SUPER(mesh), vertexCount); SUPER(mesh)->worldVerticesLength = vertexCount << 1; mesh->hullLength = readVarint(self, true) << 1; spMeshAttachment_updateUVs(mesh); spAttachmentLoader_configureAttachment(self->attachmentLoader, attachment); break; } case SP_ATTACHMENT_LINKED_MESH: { spMeshAttachment *mesh; char *parent; char *skinName; char *path = readString(self); if (path == NULL) path = name; attachment = spAttachmentLoader_createAttachment(self->attachmentLoader, skin, SP_ATTACHMENT_LINKED_MESH, name, path); mesh = SUB_CAST(spMeshAttachment, attachment); if (path) { mesh->path = copyString(path); } readColor(self, &mesh->r, &mesh->g, &mesh->b, &mesh->a); skinName = readString(self); parent = readString(self); mesh->inheritDeform = readBoolean(self); addLinkedMesh(self, mesh, skinName, slotIndex, parent); break; } case SP_ATTACHMENT_PATH: { spPathAttachment *path; int vertexCount; attachment = spAttachmentLoader_createAttachment(self->attachmentLoader, skin, SP_ATTACHMENT_PATH, name, NULL); path = SUB_CAST(spPathAttachment, attachment); path->closed = readBoolean(self); path->constantSpeed = readBoolean(self); vertexCount = readVarint(self, true); readVertices(self, SUPER(path), vertexCount); SUPER(path)->worldVerticesLength = vertexCount << 1; path->lengthsLength = vertexCount / 3; path->lengths = MALLOC(float, path->lengthsLength); for (int i = 0; i < path->lengthsLength; i++) { path->lengths[i] = readFloat(self) * self->scale; } break; } } return attachment; }
bool Configurator::readConfiguration (const char *filename) { std::ifstream file(filename == 0 ? Configurator::filename : filename); if (!file.good()) return false; int version; if (!readInt(file, version) || (version != 1 && version != 2 && version != 3)) return false; int routerCount; if (!readInt(file, routerCount) || routerCount < 0) return false; for (int i = 0; i != routerCount; ++i) { std::string interface; int vrid; int addressFamily; int priority; int interval; bool accept; bool preempt; bool enabled; int flags; IpAddress primaryIp; int addressCount; IpSubnetSet subnets; std::string masterCommand; std::string backupCommand; int vlanId; // Read data if ( !readString(file, interface) || !readInt(file, vrid) || !readInt(file, addressFamily) || !readInt(file, priority) || !readInt(file, interval) || !readBoolean(file, accept) || !readBoolean(file, preempt) || !readBoolean(file, enabled) || !readInt(file, flags)) { return false; } if (flags & FLAG_HAS_PRIMARY_IP_ADDRESS) { if (!readIp(file, primaryIp)) return false; } if (version > 1) { if (!readString(file, masterCommand) || !readString(file, backupCommand)) return false; } if (version > 2) { if (!readInt(file, vlanId)) return false; } if (!readInt(file, addressCount)) return false; for (int j = 0; j != addressCount; ++j) { IpSubnet subnet; if (!readSubnet(file, subnet)) return false; subnets.insert(subnet); } // Sanitize if (vrid < 1 || vrid > 255) { // TODO - Add to log continue; } if (priority < 1 || priority > 255) { // TODO - Add to log continue; } if (addressFamily != AF_INET && addressFamily != AF_INET6) { // TODO - Add to log continue; } if (interval % 10 != 0 || interval < 10 || interval > 40950) { // TODO - Add to log continue; } int ifIndex = if_nametoindex(interface.c_str()); if (ifIndex <= 0) { // TODO - Add to log continue; } // Create service VrrpService *service = VrrpManager::getService(ifIndex, vrid, vlanId, addressFamily, true); if (service == 0) { // TODO - Add to log continue; } service->setPriority(priority); service->setAdvertisementInterval(interval / 10); service->setAcceptMode(accept); service->setPreemptMode(preempt); if (flags & FLAG_HAS_PRIMARY_IP_ADDRESS) service->setPrimaryIpAddress(primaryIp); service->setMasterCommand(masterCommand); service->setBackupCommand(backupCommand); for (IpSubnetSet::const_iterator subnet = subnets.begin(); subnet != subnets.end(); ++subnet) { service->addIpAddress(*subnet); } if (enabled) service->enable(); else service->disable(); } return true; }
TDefMech read_TDefMech(int numJugador, int numMech){ TDefMech d; char path[32]; sprintf(path, "%s%i-%i%s", "defmechJ", numJugador, numMech, ".sbt"); FILE * sbt = fopen(path, "r"); if(sbt == NULL){ char aux[128]; sprintf(aux, "%s%s%s", "Error Apertura: No se puede abrir el fichero defMech ", path, "\n"); write_LogStatus(aux); exit(-1); } if(checkSbt(sbt, "defmechSBT")){ readNombre (sbt, d.nombre); readNombre (sbt, d.modelo); d.toneladas = readInteger( sbt ); d.potencia = readInteger( sbt ); d.numRadiadoresInt = readInteger( sbt ); d.numRadiadores = readInteger( sbt ); d.tieneMASC = readBoolean(sbt); d.tieneDACMTD = readBoolean(sbt); d.tieneDACMTI = readBoolean(sbt); d.tieneDACMTC = readBoolean(sbt); d.maxCalorGenerado = readInteger( sbt ); d.conBrazos = readBoolean(sbt); d.conHombroIzq = readBoolean(sbt); d.conBrazoIzq = readBoolean(sbt); d.conAnteBrazoIzq = readBoolean(sbt); d.conManoIzq = readBoolean(sbt); d.conHombroDer = readBoolean(sbt); d.conBrazoDer = readBoolean(sbt); d.conAnteBrazoDer = readBoolean(sbt); d.conManoDer = readBoolean(sbt); d.blinBrazoIzq = readInteger( sbt ); d.blinTorsoIzq = readInteger( sbt ); d.blinPiernaIzq = readInteger( sbt ); d.blinPiernaDer = readInteger( sbt ); d.blinTorsoDer = readInteger( sbt ); d.blinBrazoDer = readInteger( sbt ); d.blinTorsoCen = readInteger( sbt ); d.blinCabeza = readInteger( sbt ); d.blinAtrasTorsoIzq = readInteger( sbt ); d.blinAtrasTorsoDer = readInteger( sbt ); d.blinAtrasTorsoCen = readInteger( sbt ); d.ptsEstIntBrazoIzq = readInteger( sbt ); d.ptsEstIntTorsoIzq = readInteger( sbt ); d.ptsEstIntPiernaIzq = readInteger( sbt ); d.ptsEstIntPiernaDer = readInteger( sbt ); d.ptsEstIntTorsoDer = readInteger( sbt ); d.ptsEstIntBrazoDer = readInteger( sbt ); d.ptsEstIntTorsoCen = readInteger( sbt ); d.ptsEstIntCabeza = readInteger( sbt ); d.numComponentes = readInteger( sbt ); #if defined (_DEBUG) int linea = 2; printf("--------READ TDEFMECH--------\n"); printf("%03ic:%s\n", linea++, d.nombre); printf("%03ic:%s\n", linea++, d.modelo); printf("%03in:%i\n", linea++, d.toneladas); printf("%03in:%i\n", linea++, d.potencia); printf("%03in:%i\n", linea++, d.numRadiadoresInt); printf("%03in:%i\n", linea++, d.numRadiadores); printf("%03in:%i\n", linea++, d.tieneMASC); printf("%03in:%i\n", linea++, d.tieneDACMTD); printf("%03in:%i\n", linea++, d.tieneDACMTI); printf("%03in:%i\n", linea++, d.tieneDACMTC); printf("%03in:%i\n", linea++, d.maxCalorGenerado); printf("%03in:%i\n", linea++, d.conBrazos); printf("%03in:%i\n", linea++, d.conHombroIzq); printf("%03in:%i\n", linea++, d.conBrazoIzq); printf("%03in:%i\n", linea++, d.conAnteBrazoIzq); printf("%03in:%i\n", linea++, d.conManoIzq); printf("%03in:%i\n", linea++, d.conHombroDer); printf("%03in:%i\n", linea++, d.conBrazoDer); printf("%03in:%i\n", linea++, d.conAnteBrazoDer); printf("%03in:%i\n", linea++, d.conManoDer); printf("%03in:%i\n", linea++, d.blinBrazoIzq); printf("%03in:%i\n", linea++, d.blinTorsoIzq); printf("%03in:%i\n", linea++, d.blinPiernaIzq); printf("%03in:%i\n", linea++, d.blinPiernaDer); printf("%03in:%i\n", linea++, d.blinTorsoDer); printf("%03in:%i\n", linea++, d.blinBrazoDer); printf("%03in:%i\n", linea++, d.blinTorsoCen); printf("%03in:%i\n", linea++, d.blinCabeza); printf("%03in:%i\n", linea++, d.blinAtrasTorsoIzq); printf("%03in:%i\n", linea++, d.blinAtrasTorsoDer); printf("%03in:%i\n", linea++, d.blinAtrasTorsoCen); printf("%03in:%i\n", linea++, d.ptsEstIntBrazoIzq); printf("%03in:%i\n", linea++, d.ptsEstIntTorsoIzq); printf("%03in:%i\n", linea++, d.ptsEstIntPiernaIzq); printf("%03in:%i\n", linea++, d.ptsEstIntPiernaDer); printf("%03in:%i\n", linea++, d.ptsEstIntTorsoDer); printf("%03in:%i\n", linea++, d.ptsEstIntBrazoDer); printf("%03in:%i\n", linea++, d.ptsEstIntTorsoCen); printf("%03in:%i\n", linea++, d.ptsEstIntCabeza); printf("%03in:%i\n", linea++, d.numComponentes); #endif d.componentes = (TComponente *) malloc(d.numComponentes * sizeof(TComponente)); for(int i = 0; i < d.numComponentes; i++){ d.componentes[i].codigo = readInteger( sbt ); readNombre (sbt, d.componentes[i].nombre); d.componentes[i].clase = read_TClase(sbt); d.componentes[i].estaEnTrasera = readBoolean(sbt); d.componentes[i].locPrimaria = read_TLocDF(sbt); d.componentes[i].locSecundaria = read_TLocDF(sbt); d.componentes[i].tipoArma = read_TArma(sbt); d.componentes[i].calor = readInteger( sbt ); d.componentes[i].danio = readInteger( sbt ); d.componentes[i].disparosPorTurnos = readInteger( sbt ); d.componentes[i].distMinima = readInteger( sbt ); d.componentes[i].distCorta = readInteger( sbt ); d.componentes[i].distMedia = readInteger( sbt ); d.componentes[i].distLarga = readInteger( sbt ); d.componentes[i].estaOperativo = readBoolean(sbt); d.componentes[i].codigoArma = readInteger( sbt ); d.componentes[i].cantidad = readInteger( sbt ); d.componentes[i].esMunicionEspecial = readBoolean(sbt); d.componentes[i].modiDisparo = readInteger( sbt ); #if defined (_DEBUG) printf("%03in:%i\n", linea++, d.componentes[i].codigo); printf("%03ic:%s\n", linea++, d.componentes[i].nombre); printf("%03in:%i\n", linea++, d.componentes[i].clase); printf("%03in:%i\n", linea++, d.componentes[i].estaEnTrasera); printf("%03in:%i\n", linea++, d.componentes[i].locPrimaria); printf("%03in:%i\n", linea++, d.componentes[i].locSecundaria); printf("%03in:%i\n", linea++, d.componentes[i].tipoArma); printf("%03in:%i\n", linea++, d.componentes[i].calor); printf("%03in:%i\n", linea++, d.componentes[i].danio); printf("%03in:%i\n", linea++, d.componentes[i].disparosPorTurnos); printf("%03in:%i\n", linea++, d.componentes[i].distMinima); printf("%03in:%i\n", linea++, d.componentes[i].distCorta); printf("%03in:%i\n", linea++, d.componentes[i].distMedia); printf("%03in:%i\n", linea++, d.componentes[i].distLarga); printf("%03in:%i\n", linea++, d.componentes[i].estaOperativo); printf("%03in:%i\n", linea++, d.componentes[i].codigoArma); printf("%03in:%i\n", linea++, d.componentes[i].cantidad); printf("%03in:%i\n", linea++, d.componentes[i].esMunicionEspecial); printf("%03in:%i\n", linea++, d.componentes[i].modiDisparo); #endif } d.numArmas = readInteger(sbt); d.numActuadores = readInteger(sbt); #if defined (_DEBUG) printf("%03in:%i\n", linea++, d.numArmas); printf("%03in:%i\n", linea++, d.numActuadores); #endif d.actuadores = (TActuador *) malloc(d.numActuadores * sizeof(TActuador)); for(int i = 0; i < d.numActuadores; i++){ d.actuadores[i].codigo = readInteger(sbt); readNombre(sbt, d.actuadores[i].nombre); d.actuadores[i].loc = read_TLocDF(sbt); d.actuadores[i].estaOperativo = readBoolean(sbt); d.actuadores[i].numImpactos = readInteger(sbt); #if defined (_DEBUG) printf("%03in:%i\n", linea++, d.actuadores[i].codigo); printf("%03ic:%s\n", linea++, d.actuadores[i].nombre); printf("%03in:%i\n", linea++, d.actuadores[i].loc); printf("%03in:%i\n", linea++, d.actuadores[i].estaOperativo); printf("%03in:%i\n", linea++, d.actuadores[i].numImpactos); #endif } for(int i = 0; i <= 7; i++){ d.loc[i].numSlotOcupados = readInteger(sbt); #if defined (_DEBUG) printf("%03inumSlots:%i\n", linea++, d.loc[i].numSlotOcupados); #endif d.loc[i].slots = (TSlotOcupado *) malloc(d.loc[i].numSlotOcupados * sizeof(TSlotOcupado)); for(int j = 0; j < d.loc[i].numSlotOcupados; j++){ d.loc[i].slots[j].clase = read_TClase(sbt); d.loc[i].slots[j].cantidad = readInteger(sbt); d.loc[i].slots[j].codigo = readInteger(sbt); readNombre(sbt, d.loc[i].slots[j].nombre); d.loc[i].slots[j].indiceComponente = readInteger(sbt); d.loc[i].slots[j].indiceActuador = readInteger(sbt); d.loc[i].slots[j].dmgEnCasoCritico = readInteger(sbt); #if defined (_DEBUG) printf("%03iclase:%i\n", linea++, d.loc[i].slots[j].clase); printf("%03icant:%i\n", linea++, d.loc[i].slots[j].cantidad); printf("%03icod:%i\n", linea++, d.loc[i].slots[j].codigo); printf("%03inom:%s\n", linea++, d.loc[i].slots[j].nombre); printf("%03iindCom:%i\n", linea++, d.loc[i].slots[j].indiceComponente); printf("%03iindAct:%i\n", linea++, d.loc[i].slots[j].indiceActuador); printf("%03idmg:%i\n", linea++, d.loc[i].slots[j].dmgEnCasoCritico); #endif } } d.ptsMovAndando = readInteger(sbt); d.ptsMovCorriendo = readInteger(sbt); d.ptsMovSaltando = readInteger(sbt); d.tipoRadiadores = read_TRadiador(sbt); #if defined (_DEBUG) printf("%03in:%i\n", linea++, d.ptsMovAndando); printf("%03in:%i\n", linea++, d.ptsMovCorriendo); printf("%03in:%i\n", linea++, d.ptsMovSaltando); printf("%03in:%i\n", linea++, d.tipoRadiadores); printf("------FIN READ TDEFMECH-----------\n"); #endif } fclose(sbt); return d; }
bool Config::load(const char *filename) { pState = luaL_newstate(); if(luaL_dofile(pState, filename)){ printf("parse config file error=%s\n", lua_tostring(pState, -1)); return false; } //basic option sFile = filename;//file sHost = readString("HOST");//host nPort = readInt("PORT");//port bDaemonize = readBoolean("DAEMONIZE"); sLogFile = readString("LOG_FILE");//log file nLogLevel = readInt("LOG_LEVEL");//log level bRouter = readBoolean("ROUTER");//router server //router == 1 if(bRouter){ return true; } //worker option nServerId = readInt("SERVER_ID"); bEventConnect = readBoolean("EVENT_CONNECT"); bEventClose = readBoolean("EVENT_CLOSE"); nWorkers = readInt("WORKER_NUM"); if(nWorkers < 1){ printf("WORKER_NUM Invalid(WORKER_NUM>=1)\n"); return false; } nMaxClients = readInt("MAX_CLIENT_NUM"); if(nMaxClients < 1){ printf("MAX_CLIENT_NUM Invalid(MAX_CLIENT_NUM>=1)\n"); return false; } nSendBufferSize = readInt("SEND_BUFF_SIZE"); if(nSendBufferSize < 1){ printf("SEND_BUFF_SIZE Invalid(SEND_BUFF_SIZE>=1)\n"); return false; } nRecvBufferSize = readInt("RECV_BUFF_SIZE"); if(nRecvBufferSize < 1){ printf("RECV_BUFF_SIZE Invalid(RECV_BUFF_SIZE>=1)\n"); return false; } //暂时只能fastcgi nProtocol = readInt("PROTOCOL"); //backend server list nBackendTimeout = readInt("BACKEND_TIMEOUT"); lua_getglobal(pState, "BACKEND_SERVER"); if(lua_isstring(pState, -1)){ const char *val = lua_tostring(pState, -1); if(!addBackendServer(val, 1)){ printf("BACKEND_SERVER Invalid\n"); return false; } }else if(lua_istable(pState, -1)){ lua_pushnil(pState); while(lua_next(pState, -2)) { const char *str = NULL; int weight = 0; if(lua_isstring(pState, -2)){ str = lua_tostring(pState, -2); } if(lua_isnumber(pState, -1)){ weight = lua_tonumber(pState, -1);; } if(str && weight > 0){ if(!addBackendServer(str, weight)){ printf("BACKEND_SERVER Invalid\n"); return false; } } lua_pop(pState, 1); } lua_pop(pState, 1); }else{ printf("BACKEND_SERVER invalid\n"); return false; } //router option sScriptFile = readString("SCRIPT_FILE"); sRouterHost = readString("ROUTER_HOST"); nRouterPort = readInt("ROUTER_PORT"); //fastcgi sFastcgiRoot = readString("FASTCGI_ROOT"); sFastcgiFile = readString("FASTCGI_FILE"); //fastcgi params lua_getglobal(pState, "FASTCGI_PARAMS"); if(lua_istable(pState, -1)){ lua_pushnil(pState); while(lua_next(pState, -2)) { const char *key = NULL; const char *val = NULL; if(lua_isstring(pState, -2)){ key = lua_tostring(pState, -2); } if(lua_isstring(pState, -1)){ val = lua_tostring(pState, -1); } if(key && val){ arFastcgiParams[key] = val; } lua_pop(pState, 1); } lua_pop(pState, 1); }else{ printf("FASTCGI_PARAMS invalid\n"); return false; } return true; }