void init(int max_sim_time) { #ifdef STANDALONE printf(" Initializing TraCI...\n"); #else LOG_N(OMG, " Initializing TraCI...\n"); #endif char *objID = " "; // size_t size = strlen(objID); int noSubscribedVars = 2; writeUnsignedByte(0); writeInt(1 + 4 + 1 + 4 + 4 + 4 + (int) strlen(objID) + 1 + noSubscribedVars); writeUnsignedByte(CMD_SUBSCRIBE_SIM_VARIABLE); // command id writeInt(0); // begin time writeInt(max_sim_time*1000); // end time writeString(objID); // object id writeUnsignedByte(noSubscribedVars); // variable number writeUnsignedByte(VAR_DEPARTED_VEHICLES_IDS); writeUnsignedByte(VAR_ARRIVED_VEHICLES_IDS); // send request message sendExact(storageLength(storageStart)); extractCommandStatus(receiveExact(), CMD_SUBSCRIBE_SIM_VARIABLE, description); if (departed == NULL) { departed = (string_list*) malloc(sizeof(string_list)); // departed MUST point to HEAD departed->string = NULL; departed->next = NULL; } if (arrived == NULL) { arrived = (string_list*) malloc(sizeof(string_list)); // arrived MUST point to HEAD arrived->string = NULL; arrived->next = NULL; } processSubscriptions(); reset(); }
static TACommandVerdict gzgetc_cmd(TAThread thread,TAInputStream stream) { void* file; int res, errnum; file = readPointer(&stream); START_TARGET_OPERATION(thread); res = gzgetc(file); END_TARGET_OPERATION(thread); gzerror(file, &errnum); writeInt(thread, errnum); writeInt(thread, res); sendResponse(thread); return taDefaultVerdict; }
void memorySnapshot(){ int userMemoryUsage = 0; int allocMemoryUsage = 0; long long unsigned lastUsedByte = (long long unsigned)memoryAdress; long long unsigned firstUsedByte = (long long unsigned)memoryAdress; long long unsigned firstBlockByte = (long long unsigned)memoryAdress; long long unsigned lastBlockByte = (long long unsigned)memoryAdress; struct ab* a = headAllocatedB; int fd = dataFile; while (a!=NULL){ userMemoryUsage += a->size; firstBlockByte = (long long unsigned)a; lastBlockByte = firstBlockByte + a->size + sizeof(struct ab); if ( firstBlockByte <= firstUsedByte ){ firstUsedByte = firstUsedByte; } if ( lastUsedByte <= lastBlockByte ){ lastUsedByte = lastBlockByte; } allocMemoryUsage = lastUsedByte - firstUsedByte; a = a->next; } writeInt(fd, instant); write(fd," ",1); writeInt(fd, userMemoryUsage); write(fd," ",1); writeInt(fd, allocMemoryUsage); write(fd,"\n",1); instant++; return ; }
static TACommandVerdict wcsxfrm_cmd(TAThread thread, TAInputStream stream) { wchar_t* ws1; wchar_t* ws2; wchar_t* xxx = L""; size_t n; size_t res; int save_errno; int overflow = 0; int i; // Prepare ws2 = ta_wcsalign(readWString(&stream)); //align on copy n = readSize(&stream); ws1 = ta_alloc_memory((n + BUFFER_TAIL) * sizeof(wchar_t)); for (i=0; i<BUFFER_TAIL; ++i) ws1[n + i] = (wchar_t)0xDDDDDDDD; START_TARGET_OPERATION(thread); // Execute errno = 0; res = wcsxfrm(ws1, ws2, n); save_errno = errno; END_TARGET_OPERATION(thread); for (i=0; i<BUFFER_TAIL; ++i) overflow |= (ws1[n + i] != (wchar_t)0xDDDDDDDD); if (overflow) { sendException(thread, "wcsxfrm.02 failed: writing outside of buffer limits occured!"); return taDefaultVerdict; } // Response if (res >= n) writeWString(thread, xxx); else writeWString(thread, ws1); writeSize(thread, res); writeInt(thread, save_errno); sendResponse(thread); ta_dealloc_memory(ws1); ta_dealloc_memory(ws2); return taDefaultVerdict; }
int main() { int n; n=readlong(); int i,j; for(i=2; i<=100; i++) { number[0][i]=0; } for(i=1; i<=n; i++) { int a; a=readlong(); for(j=1; j<=100; j++) number[i][j]=number[i-1][j]; number[i][a]++; } int t; t=readlong(); int l,r; long long MOD; while(t--) { l=readlong(); r=readlong(); MOD=readlong(); long long ans=1; if(MOD==1) printf("%d\n",0); else { for(i=1; i<=100; i++) { if(number[r][i]-number[l-1][i]) { ans=ans*p(i,number[r][i]-number[l-1][i],MOD); ans=ans%MOD; } } writeInt(ans); } } return 0; }
/* Display the amount of money stored in the user's cloud provider account. */ int clientWalletBalance(BIO *conn) { //send the code which triggers the server to call serverWalletBalance() if(writeInt(conn, WALLET_BALANCE_CODE) == -1) return -1; //read the balance back from the server int balance = readInt(conn); if(balance == -1) { fprintf(stderr, "Failed to get balance.\n"); return -1; } printf("You have %d cloud dollars in your cloud wallet.\n", balance); return 0; }
static TACommandVerdict getpriority_cmd(TAThread thread,TAInputStream stream) { int which; int who ; int res ; // Prepare which = readInt( & stream ); who = readInt( & stream ); errno = 0; // Execute START_TARGET_OPERATION(thread); res = getpriority( which, who ); END_TARGET_OPERATION(thread); // Response writeInt( thread, res ); writeInt( thread, errno ); sendResponse( thread ); return taDefaultVerdict; }
// interrupt service routine to manage interrupt vector table void handleInterrupt21(int ax, int bx, int cx, int dx){ if (ax==0){ printString(bx); } else if (ax==1){ readString(bx); } else if (ax==2){ readSector(bx,cx); } else if (ax==3){ readFile(bx,cx,dx); } else if (ax==4){ runProgram(bx,cx); } else if (ax==5){ stop(); } else if (ax==6){ writeSector(bx,cx); } else if (ax==7) { deleteFile(bx); } else if (ax==8){ writeFile(bx,cx,dx); } else if (ax==11){ interrupt(25,0,0,0,0); } else if (ax==12){ clearScreen(bx,cx); } else if (ax==13){ writeInt(bx); } else if (ax==14){ ReadInt(bx); } else if (ax==15){ error(bx); } else if (ax==66){ printChar(bx); } else { printString("Incorrect service call\0"); } }
static TACommandVerdict gzprintf_cmd(TAThread thread,TAInputStream stream) { void* file; char* s; int res, errnum; file = readPointer(&stream); s = readString(&stream); START_TARGET_OPERATION(thread); res = gzprintf(file, s); END_TARGET_OPERATION(thread); writeInt(thread, errnum); writeInt(thread, errno); writeInt(thread, res); sendResponse(thread); return taDefaultVerdict; }
static TACommandVerdict nice_cmd(TAThread thread,TAInputStream stream) { int incr; int res ; // ta_debug_printf( "[%3d]", nice( 0 ) ); // Prepare incr = readInt( & stream ); errno = 0; // Execute START_TARGET_OPERATION(thread); res = nice( incr ); END_TARGET_OPERATION(thread); // ta_debug_printf( "[%3d|%3d|%3d|%3d|%3d|%3d]\n", res, incr, getuid(), geteuid(), getgid(), getegid() ); // Response writeInt( thread, res ); writeInt( thread, errno ); sendResponse( thread ); return taDefaultVerdict; }
int MQTTSPacket_send_regAck(Clients* client, int msgId, int topicId, char returnCode) { MQTTS_RegAck packet; int rc = 0; char *buf, *ptr; int datalen = 5; FUNC_ENTRY; packet.header.len = 7; packet.header.type = MQTTS_REGACK; ptr = buf = malloc(datalen); writeInt(&ptr, topicId); writeInt(&ptr, msgId); writeChar(&ptr, returnCode); rc = MQTTSPacket_send(client, packet.header, buf, datalen); free(buf); Log(LOG_PROTOCOL, 52, NULL, client->socket, client->addr, client->clientID, msgId, topicId, returnCode, rc); FUNC_EXIT_RC(rc); return rc; }
void writeString(char *s) { int count=0; char* s_copy=s; for(; *s!='\0'; s++) count++; writeInt(count); for(; *s_copy!='\0'; s_copy++) writeChar(*s_copy); }
void BPlusTree::insert_in_leaf( TreeNode* L, int key, int rid) { BufferManager *bm = BufferManager::getInstance(); if(key < L->getKey(1)) { cout<<"inif2"<<endl; //inserting the key-pointer pair at the start of the node moveBytes( L->getBuffPage(), 8, 16, (L->getTotalPairs())*8 ); writeInt( L->getBuffPage(), 0, L->getTotalPairs() + 1 ); cout<<readInt( L->getBuffPage(), 0)<<endl; } else { cout<<"inelse2"<<endl; int totPairs = L->getTotalPairs(); int i = totPairs; //finding the location to insert while(key<L->getKey(i)){ cout<<"inwhile\n"; i--; if(key>L->getKey(i)) break; } cout<<"outofwhile\n"; i++; //inserting the key-pointer pair at the correct location cout<<i<<" "<<L->getTotalPairs()<<"\n"; moveBytes( L->getBuffPage(), 16+8*i, 8+8*i, (L->getTotalPairs())-i ); cout<<"moved\n"; writeInt( L->getBuffPage(), 8+8*i, rid ); cout<<"write\n"; writeInt( L->getBuffPage(), 12+8*i, key ); cout<<"write1\n"; writeInt( L->getBuffPage(), 0, L->getTotalPairs() + 1 ); cout<<"written all data"; } }
static TACommandVerdict getgrent_cmd(TAThread thread,TAInputStream stream) { struct group* result; int i=0; errno = 0; START_TARGET_OPERATION_WHICH_MAY_CONTAIN_CANCELPOINT(thread); result = getgrent(); END_TARGET_OPERATION_WHICH_MAY_CONTAIN_CANCELPOINT(thread); writePointer(thread,(void*)result); if(result) { writeString(thread, result->gr_name); writeInt(thread, result->gr_gid); while ((result->gr_mem)[i]!=NULL) { i++; } writeInt(thread, i); i=0; while ((result->gr_mem)[i]!=NULL) { writeString(thread, (result->gr_mem)[i]); i++; } } writeInt(thread,errno); sendResponse(thread); return taDefaultVerdict; }
static TACommandVerdict setkey_cmd(TAThread thread,TAInputStream stream) { char* key; int i; // Prepare key=(char*)readPointer(&stream); ta_debug_printf("setkey:\n"); for(i=0;i<64;i++) ta_debug_printf("%d ", key[i]); ta_debug_printf("\n"); START_TARGET_OPERATION(thread); errno=0; setkey(key); END_TARGET_OPERATION(thread); // Response writeInt(thread, errno); sendResponse(thread); return taDefaultVerdict; }
/* * LIST FILES : CLIENT SIDE * * Handle the client side of the list files funcitonality */ int clientListFiles(BIO *conn) { //send the code which causes the server to call serverListFiles() */ if(writeInt(conn, LIST_FILES_CODE) == -1) return -1; //catch the server's response, a single string listing all files //from the folder char buffer[BUFFER_SIZE]; if(readPacket(conn, buffer, sizeof(buffer)) < 1) return -1; //display the file listing printf("Your files:\n"); printf("%s", buffer); return 1; }
int MQTTSPacket_send_subAck(Clients* client, MQTTS_Subscribe* sub, int topicId, int qos, char returnCode) { MQTTS_SubAck packet; int rc = 0; char *buf, *ptr; int datalen = 6; FUNC_ENTRY; packet.header.len = 8; packet.header.type = MQTTS_SUBACK; ptr = buf = malloc(datalen); packet.flags.QoS = qos; writeChar(&ptr, packet.flags.all); writeInt(&ptr, topicId); writeInt(&ptr, sub->msgId); writeChar(&ptr, returnCode); rc = MQTTSPacket_send(client, packet.header, buf, datalen); free(buf); Log(LOG_PROTOCOL, 68, NULL, client->socket, client->addr, client->clientID, sub->msgId, topicId, returnCode, rc); FUNC_EXIT_RC(rc); return rc; }
static TACommandVerdict insertln_cmd(TAThread thread,TAInputStream stream) { int res; START_TARGET_OPERATION(thread); res = insertln(); END_TARGET_OPERATION(thread); writeInt(thread, res); sendResponse(thread); return taDefaultVerdict; }
int MQTTSPacket_send_register(Clients* client, int topicId, char* topicName, int msgId) { MQTTS_Register packet; int rc = 0; char *buf, *ptr; int datalen = 4 + strlen(topicName); FUNC_ENTRY; packet.header.len = datalen+2; packet.header.type = MQTTS_REGISTER; ptr = buf = malloc(datalen); writeInt(&ptr, topicId); writeInt(&ptr, msgId); memcpy(ptr, topicName, strlen(topicName)); rc = MQTTSPacket_send(client, packet.header, buf, datalen); free(buf); Log(LOG_PROTOCOL, 50, NULL, client->socket, client->addr, client->clientID, msgId, topicId, topicName, rc); FUNC_EXIT_RC(rc); return rc; }
static TACommandVerdict mkfifo_cmd(TAThread thread,TAInputStream stream) { char* path; int mode; int res; // Prepare path = readString(&stream); mode = readFilePermissions(&stream); errno = 0; START_TARGET_OPERATION(thread); res = mkfifo(path, mode); END_TARGET_OPERATION(thread); // Response writeInt(thread,res); writeInt(thread,errno); sendResponse(thread); return taDefaultVerdict; }
void deleteByOffset(DeletionHandler *dh, long offset) { long head = readLong(dh->bfr, 0L); // read head seekBinaryFile(dh->bfr->bf, offset); // point to offset int size = readInt(dh->bfr, getStreamOffset(dh->bfr->bf)); size *= -1; // delete seekBinaryFile(dh->bfw->bf, offset); writeInt(dh->bfw, size, getStreamOffset(dh->bfw->bf)); // write deleted seekBinaryFile(dh->bfw->bf, (offset + sizeof(int))); writeLong(dh->bfw, head, getStreamOffset(dh->bfw->bf)); // write head writeLong(dh->bfw, offset, 0L); // updated head with new offset }
static TACommandVerdict writev_fifo_cmd(TAThread thread,TAInputStream stream) { int fildes; int size; int i=0; void* curPointer; size_t curSize; struct iovec *iov; ssize_t res; // Prepare fildes = readInt(&stream); size = readInt(&stream); iov=(struct iovec *)ta_alloc_memory(size*sizeof(struct iovec)); for (i=0;i<size;i++) { curPointer=readPointer(&stream); curSize=readSize(&stream); iov[i].iov_base=curPointer; iov[i].iov_len=curSize; } BEFORE_BLOCKED_TARGET_OPERATION(thread); writeString(thread,"Ok"); sendResponse(thread); errno = 0; START_TARGET_OPERATION(thread); res = writev(fildes, iov, size); END_TARGET_OPERATION(thread); writeDeferredReaction(thread, "writev_fifo_return"); // Response writeSSize(thread,res); writeInt(thread,errno); sendResponse(thread); ta_dealloc_memory(iov); return taDefaultVerdict; }
static TACommandVerdict z_stream_size_cmd(TAThread thread,TAInputStream stream) { int res; START_TARGET_OPERATION(thread); res = sizeof(z_stream); END_TARGET_OPERATION(thread); // Response writeInt(thread, res); sendResponse(thread); return taDefaultVerdict; }
int main() { generate_hashmap(); int n; n=readlong(); int i,j; for(i=0;i<25;i++) { number[0][i]=0; } for(i=1;i<=n;i++) { int a; a=readlong(); for(j=0;j<25;j++) number[i][j]=number[i-1][j]+hashmap[a][j]; } int t; t=readlong(); int l,r; long long MOD; while(t--) { l=readlong(); r=readlong(); MOD=readlong(); long long ans=1; for(i=0;i<25;i++) { if(number[r][i]-number[l-1][i]) { ans=ans*p(prime[i],number[r][i]-number[l-1][i],MOD); ans=ans%MOD; } } writeInt(ans); } return 0; }
/** * Send an MQTT acknowledgement packet down a socket. * @param type the MQTT packet type e.g. SUBACK * @param msgid the MQTT message id to use * @param dup boolean - whether to set the MQTT DUP flag * @param socket the open socket to send the data to * @return the completion code (e.g. TCPSOCKET_COMPLETE) */ int MQTTPacket_send_ack(int type, int msgid, int dup, int socket) { Header header; int rc; char *buf = malloc(2); char *ptr = buf; FUNC_ENTRY; header.byte = 0; header.bits.type = type; header.bits.dup = dup; writeInt(&ptr, msgid); if ((rc = MQTTPacket_send(socket, header, buf, 2)) != TCPSOCKET_INTERRUPTED) free(buf); FUNC_EXIT_RC(rc); return rc; }
int MQTTSPacket_send(int socket, char* addr, MQTTSHeader header, char* buffer, int buflen) { int rc = 0; char *data = NULL; char *ptr = NULL; PacketBuffer buf; FUNC_ENTRY; if (header.len > 256) { header.len += 2; buflen += 2; data = malloc(header.len); ptr = data; *ptr++ = 0x01; writeInt(&ptr, header.len); } else { data = malloc(header.len); ptr = data; *ptr++ = header.len; } *ptr++ = header.type; memcpy(ptr, buffer, buflen); buf.data = data; buf.len = buflen + 2; rc = MQTTSPacket_sendPacketBuffer(socket, addr, buf); if (rc == SOCKET_ERROR) { Socket_error("sendto", socket); /* if (err == EWOULDBLOCK || err == EAGAIN) rc = TCPSOCKET_INTERRUPTED; */ } else rc = 0; free(data); FUNC_EXIT_RC(rc); return rc; }
PacketBuffer MQTTSPacketSerialize_advertise(unsigned char gateway_id, short duration) { MQTTSHeader header; PacketBuffer buf; FUNC_ENTRY; header.len = 5; header.type = MQTTS_ADVERTISE; buf = MQTTSPacketSerialize_header(header); writeChar(&buf.ptr, gateway_id); writeInt(&buf.ptr, duration); FUNC_EXIT; return buf; }
void WKBWriter::writeCoordinateSequence(const CoordinateSequence& cs, bool sized) { std::size_t size = cs.getSize(); bool is3d = false; if(outputDimension > 2) { is3d = true; } if(sized) { writeInt(static_cast<int>(size)); } for(std::size_t i = 0; i < size; i++) { writeCoordinate(cs, i, is3d); } }
/* Add horizontal advance width. */ static void glyphWidth(abfGlyphCallbacks *cb, float hAdv) { ufwCtx h = cb->direct_ctx; if (h->err.code != 0) return; /* Pending error */ else if (h->path.state != 1) { /* Call sequence error */ h->err.code = ufwErrBadCall; return; } writeStr(h, "\t<advance width=\""); writeInt(h, (long)roundf(hAdv)); writeLine(h, "\"/>"); h->path.state = 2; }
/** * Send an MQTT subscribe packet down a socket. * @param topics list of topics * @param qoss list of corresponding QoSs * @param msgid the MQTT message id to use * @param dup boolean - whether to set the MQTT DUP flag * @param socket the open socket to send the data to * @param clientID the string client identifier, only used for tracing * @return the completion code (e.g. TCPSOCKET_COMPLETE) */ int MQTTPacket_send_subscribe(List* topics, List* qoss, uint64_t msgid, int dup, networkHandles* net, const char* clientID) { Header header; char *data, *ptr; int rc = -1; ListElement *elem = NULL, *qosElem = NULL; int datalen; int mqtt_version = get_client_mqtt_version_from_network_handler(net); FUNC_ENTRY; header.bits.type = SUBSCRIBE; header.bits.dup = dup; header.bits.qos = 1; header.bits.retain = 0; //8 -> 64 bit msg id. if the msgid is 2 Byte, datalen will be decresed datalen = 8 + topics->count * 3; // utf length + char qos == 3 while (ListNextElement(topics, &elem)) datalen += strlen((char*)(elem->content)); ptr = data = malloc(datalen); if(mqtt_version == MQTTVERSION_YUNBA_3_1) { writeInt64(&ptr, msgid); }else{ msgid = (int)msgid; writeInt(&ptr, msgid); //make sure the datalen is adjusted datalen -= 6; } elem = NULL; while (ListNextElement(topics, &elem)) { ListNextElement(qoss, &qosElem); writeUTF(&ptr, (char*)(elem->content)); writeChar(&ptr, *(int*)(qosElem->content)); } rc = MQTTPacket_send(net, header, data, datalen, 1); Log(LOG_PROTOCOL, 22, NULL, net->socket, clientID, msgid, rc); if (rc != TCPSOCKET_INTERRUPTED) free(data); FUNC_EXIT_RC(rc); return rc; }