PackedPayloadHashTable::PackedPayloadHashTable( const std::vector<const Type *> &key_types, const std::size_t num_entries, const std::vector<AggregationHandle *> &handles, StorageManager *storage_manager) : key_types_(key_types), num_handles_(handles.size()), handles_(handles), total_payload_size_(ComputeTotalPayloadSize(handles)), storage_manager_(storage_manager), kBucketAlignment(alignof(std::atomic<std::size_t>)), kValueOffset(sizeof(std::atomic<std::size_t>) + sizeof(std::size_t)), key_manager_(key_types_, kValueOffset + total_payload_size_), bucket_size_(ComputeBucketSize(key_manager_.getFixedKeySize())) { std::size_t payload_offset_running_sum = sizeof(SpinMutex); for (const auto *handle : handles) { payload_offsets_.emplace_back(payload_offset_running_sum); payload_offset_running_sum += handle->getPayloadSize(); } // NOTE(jianqiao): Potential memory leak / double freeing by copying from // init_payload to buckets if payload contains out of line data. init_payload_ = static_cast<std::uint8_t *>(calloc(this->total_payload_size_, 1)); DCHECK(init_payload_ != nullptr); for (std::size_t i = 0; i < num_handles_; ++i) { handles_[i]->initPayload(init_payload_ + payload_offsets_[i]); } // Bucket size always rounds up to the alignment requirement of the atomic // size_t "next" pointer at the front or a ValueT, whichever is larger. // // Give base HashTable information about what key components are stored // inline from 'key_manager_'. setKeyInline(key_manager_.getKeyInline()); // Pick out a prime number of slots and calculate storage requirements. std::size_t num_slots_tmp = get_next_prime_number(num_entries * kHashTableLoadFactor); std::size_t required_memory = sizeof(Header) + num_slots_tmp * sizeof(std::atomic<std::size_t>) + (num_slots_tmp / kHashTableLoadFactor) * (bucket_size_ + key_manager_.getEstimatedVariableKeySize()); std::size_t num_storage_slots = this->storage_manager_->SlotsNeededForBytes(required_memory); if (num_storage_slots == 0) { FATAL_ERROR( "Storage requirement for SeparateChainingHashTable " "exceeds maximum allocation size."); } // Get a StorageBlob to hold the hash table. const block_id blob_id = this->storage_manager_->createBlob(num_storage_slots); this->blob_ = this->storage_manager_->getBlobMutable(blob_id); void *aligned_memory_start = this->blob_->getMemoryMutable(); std::size_t available_memory = num_storage_slots * kSlotSizeBytes; if (align(alignof(Header), sizeof(Header), aligned_memory_start, available_memory) == nullptr) { // With current values from StorageConstants.hpp, this should be // impossible. A blob is at least 1 MB, while a Header has alignment // requirement of just kCacheLineBytes (64 bytes). FATAL_ERROR( "StorageBlob used to hold resizable " "SeparateChainingHashTable is too small to meet alignment " "requirements of SeparateChainingHashTable::Header."); } else if (aligned_memory_start != this->blob_->getMemoryMutable()) { // This should also be impossible, since the StorageManager allocates slots // aligned to kCacheLineBytes. DEV_WARNING("StorageBlob memory adjusted by " << (num_storage_slots * kSlotSizeBytes - available_memory) << " bytes to meet alignment requirement for " << "SeparateChainingHashTable::Header."); } // Locate the header. header_ = static_cast<Header *>(aligned_memory_start); aligned_memory_start = static_cast<char *>(aligned_memory_start) + sizeof(Header); available_memory -= sizeof(Header); // Recompute the number of slots & buckets using the actual available memory. // Most likely, we got some extra free bucket space due to "rounding up" to // the storage blob's size. It's also possible (though very unlikely) that we // will wind up with fewer buckets than we initially wanted because of screwy // alignment requirements for ValueT. std::size_t num_buckets_tmp = available_memory / (kHashTableLoadFactor * sizeof(std::atomic<std::size_t>) + bucket_size_ + key_manager_.getEstimatedVariableKeySize()); num_slots_tmp = get_previous_prime_number(num_buckets_tmp * kHashTableLoadFactor); num_buckets_tmp = num_slots_tmp / kHashTableLoadFactor; DEBUG_ASSERT(num_slots_tmp > 0); DEBUG_ASSERT(num_buckets_tmp > 0); // Locate the slot array. slots_ = static_cast<std::atomic<std::size_t> *>(aligned_memory_start); aligned_memory_start = static_cast<char *>(aligned_memory_start) + sizeof(std::atomic<std::size_t>) * num_slots_tmp; available_memory -= sizeof(std::atomic<std::size_t>) * num_slots_tmp; // Locate the buckets. buckets_ = aligned_memory_start; // Extra-paranoid: If ValueT has an alignment requirement greater than that // of std::atomic<std::size_t>, we may need to adjust the start of the bucket // array. if (align(kBucketAlignment, bucket_size_, buckets_, available_memory) == nullptr) { FATAL_ERROR( "StorageBlob used to hold resizable " "SeparateChainingHashTable is too small to meet " "alignment requirements of buckets."); } else if (buckets_ != aligned_memory_start) { DEV_WARNING( "Bucket array start position adjusted to meet alignment " "requirement for SeparateChainingHashTable's value type."); if (num_buckets_tmp * bucket_size_ > available_memory) { --num_buckets_tmp; } } // Fill in the header. header_->num_slots = num_slots_tmp; header_->num_buckets = num_buckets_tmp; header_->buckets_allocated.store(0, std::memory_order_relaxed); header_->variable_length_bytes_allocated.store(0, std::memory_order_relaxed); available_memory -= bucket_size_ * (header_->num_buckets); // Locate variable-length key storage region, and give it all the remaining // bytes in the blob. key_manager_.setVariableLengthStorageInfo( static_cast<char *>(buckets_) + header_->num_buckets * bucket_size_, available_memory, &(header_->variable_length_bytes_allocated)); }
bool NetSystem::Init() { WSAData wsa_data; int error = WSAStartup(MAKEWORD(2, 2), &wsa_data); if (error == 0) { NetMessageDefinition pingDef; pingDef.m_callback = PingCallback; pingDef.m_name = "ping"; pingDef.m_options |= eNMO_Connectionless; NetMessage::RegisterMessageDefinition(0, pingDef); NetMessageDefinition pongDef; pongDef.m_callback = PongCallback; pongDef.m_name = "pong"; pongDef.m_options |= eNMO_Connectionless; NetMessage::RegisterMessageDefinition(1, pongDef); NetMessageDefinition heartbeatDef; heartbeatDef.m_callback = HeartbeatCallback; heartbeatDef.m_name = "heartbeat"; NetMessage::RegisterMessageDefinition(2, heartbeatDef); NetMessageDefinition ackDef; ackDef.m_callback = AckCallback; ackDef.m_name = "ack"; NetMessage::RegisterMessageDefinition(3, ackDef); NetMessageDefinition joinRequest; joinRequest.m_callback = JoinRequestCallback; joinRequest.m_name = "joinrequest"; joinRequest.m_options |= eNMO_Reliable; joinRequest.m_options |= eNMO_Connectionless; NetMessage::RegisterMessageDefinition(4, joinRequest); NetMessageDefinition joinAccept; joinAccept.m_callback = JoinAcceptCallback; joinAccept.m_name = "joinaccept"; joinAccept.m_options |= eNMO_Reliable; NetMessage::RegisterMessageDefinition(5, joinAccept); NetMessageDefinition joinDeny; joinDeny.m_callback = JoinDenyCallback; joinDeny.m_name = "joindeny"; joinDeny.m_options |= eNMO_Connectionless; NetMessage::RegisterMessageDefinition(6, joinDeny); NetMessageDefinition leave; leave.m_callback = LeaveCallback; leave.m_name = "leave"; NetMessage::RegisterMessageDefinition(7, leave); NetMessageDefinition startTest; startTest.m_callback = StartTestCallback; startTest.m_name = "starttest"; startTest.m_options |= eNMO_Reliable; NetMessage::RegisterMessageDefinition(8, startTest); NetMessageDefinition inOrderTest; inOrderTest.m_callback = InOrderTestCallback; inOrderTest.m_name = "inordertest"; inOrderTest.m_options |= eNMO_Reliable; inOrderTest.m_options |= eNMO_InOrder; NetMessage::RegisterMessageDefinition(9, inOrderTest); NetMessageDefinition forceTest; forceTest.m_callback = ForceTestCallback; forceTest.m_name = "forcetest"; forceTest.m_options |= eNMO_Reliable; NetMessage::RegisterMessageDefinition(10, forceTest); return true; } else { FATAL_ERROR("Could not setup WSA System"); } //Create netmessage definitions here }
/** * @brief For Numeric TypeInstances, get this TypeInstance's value as a C++ * double. * @warning supportsNumericInterface() must be true and isNull() must be * false for this method to be usable. * * @return The value as a double. **/ virtual double numericGetDoubleValue() const { FATAL_ERROR("Used a Numeric interface method on a non-numeric TypeInstance."); }
/** * @brief For Numeric TypeInstances, get this TypeInstance's value as an * int64_t. * @warning supportsNumericInterface() must be true and isNull() must be * false for this method to be usable. * * @return The value as an int64_t. **/ virtual std::int64_t numericGetLongValue() const { FATAL_ERROR("Used a Numeric interface method on a non-numeric TypeInstance."); }
std::string PlayerSAO::getStaticData() { FATAL_ERROR("Deprecated function (?)"); return ""; }
/** * pm_execute * @params * int should_wait - Indicates if this execute should be inline or asynchronous * const char* command - The command to run * const char* cd - Run in this directory unless it's a NULL pointer * int nice - Special nice level * const char** env - Environment variables to run in the shell * @output pid_t pid - output pid of the new process **/ pid_t pm_execute( int should_wait, const char* command, const char *cd, int nice, const char** env, int *child_stdin, const char* p_stdout, const char *p_stderr ) { // Setup execution char **command_argv = {0}; int command_argc = 0; int running_script = 0; int countdown = 200; // If there is nothing here, don't run anything :) if (strlen(command) == 0) return -1; char* chomped_string = str_chomp(command); char* safe_chomped_string = str_safe_quote(chomped_string); if (expand_command((const char*)safe_chomped_string, &command_argc, &command_argv, &running_script, env)) ; command_argv[command_argc] = 0; // Now actually RUN it! pid_t pid; #if USE_PIPES int child_fd[2]; if ( pipe(child_fd) < 0 ) {// Create a pipe to the child (do we need this? I doubt it) perror("pipe failed"); } // Setup the stdin so the parent can communicate! (*child_stdin) = child_fd[0]; #endif // Let's name it so we can get to it later int child_dev_null; #if DEBUG if ((child_dev_null = open("debug.log", O_WRONLY|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) < 0) { syslog(LOG_ERR, "babysitter (fatal): Could not open debug.log: errno: %d\n", errno); }; #else if ((child_dev_null = open("/dev/null", O_RDWR)) < 0) { syslog(LOG_ERR, "babysitter (fatal): Could not open /dev/null: errno: %d\n", errno); }; #endif // Setup fork pm_setup_fork(); if (should_wait) pid = vfork(); else pid = fork(); switch (pid) { case -1: return -1; case 0: { // Child process pm_setup_child(); if (cd != NULL && cd[0] != '\0') safe_chdir(cd); else safe_chdir("/tmp"); int child_stdout, child_stderr; // Set everything to dev/null first child_stdout = child_stderr = child_dev_null; // If we've passed in a stdout filename, then open it if(p_stdout) if ((child_stdout = open(p_stdout, O_WRONLY|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) < 0) { perror("child stdout"); child_stdout = child_dev_null; } // If we've been passed a stderr filename, then open that if(p_stderr) if ((child_stderr = open(p_stderr, O_WRONLY|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) < 0) { perror("child stderr"); child_stderr = child_dev_null; } // Parent doesn't write anything to the child, so just close this right away // REDIRECT TO DEV/NULL // Replace the stdout/stderr with the child_write fd #if USE_PIPES if (dup2(child_fd[0], STDIN_FILENO) < 0) FATAL_ERROR("could not dup STDIN_FILENO", -1); close(child_fd[1]); // We are using a different stdout #endif #if DEBUG #else // Setup the different stdout/stderr if (dup2(child_stdout, STDOUT_FILENO) < 0) FATAL_ERROR("could not dup STDOUT_FILENO", -1); if (dup2(child_stderr, STDERR_FILENO) < 0) FATAL_ERROR("could not dup STDERR_FILENO", -1); if (child_stdout != child_dev_null) close(child_stdout); if (child_stderr != child_dev_null) close(child_stderr); #endif if (execve((const char*)command_argv[0], command_argv, (char* const*) env) < 0) { perror("execve"); exit(-1); } } default: // In parent process // set the stdout back close(child_dev_null); // Child write never gets used outside the child #if USE_PIPES if (dup2(child_fd[1], STDOUT_FILENO) < 0) perror("dup2"); close(child_fd[0]); #endif if (nice != INT_MAX && setpriority(PRIO_PROCESS, pid, nice) < 0) ; if (running_script) { while (countdown > 0) { if (kill(pid, 0) != 0) break; usleep(100); countdown--; } struct stat buffer; if (stat(command_argv[0], &buffer) != 0) { printf("file doesn't exist when it should because: %s\n", strerror(errno)); } if( unlink( command_argv[0] ) != 0 ) perror( "Error deleting file" ); } // These are free'd later, anyway // if (chomped_string) free(chomped_string); // if (safe_chomped_string) free(safe_chomped_string); return pid; } }
void SampleLoopTask::Task(){ int cnt = 0; int region; int attempt = 0; static int dout = 1; static double error = 0; int last_status = 0; double pos_prev = 0; double pCmd_prev = 0; double vCmd_prev = 0; int obj_ang_index = 0; // to keep continuous angle value when acrossing pi(or -pi). uint64_t cycle, cycle_prev; // for acceleration calculation double u = 0; double alpha = 0; double DuDeta1Bar =0; double DuDeta2 =0; double DalphaDeta1Bar =0; double DalphaDeta2 =0; double eta1Bar = 0; double z = 0; // to use eta2D in calculation of shD double eta2_prev = 0; double eta2D = 0; double eta2D_prev = 0; double elapsedSec = 0; //test double feedforwardVal = 0; uint64_t cycle1, cycle2; while(!lost){ TimerWait(); ncycles = ClockCycles(); sec=(double)(ncycles - ncycles_prev)/cps; ncycles_prev = ncycles; TimingProcess(); // Read Inputs HW->ProcessInput(); // all digital & analog, encoders reading. // Get status of camera last_status = HW->ReadDigitalBit(IoHardware::FRAME_STATUS); // Send out pulse to trigger camera HW->WriteDigitalBit(IoHardware::CAMERA_TRIGGER, 1); HW->WriteDigitalBit(IoHardware::CAMERA_TRIGGER, 0); // test //cycle1 = ClockCycles(); if(camera) {// && !lost){ // Wait for camera to process data, with timeout counter while(HW->ReadDigitalBit(IoHardware::FRAME_STATUS) == last_status){ if(++attempt == (int)(6.0e5/SAMPLE_RATE)) { // 5.0e5 must be found out by experiments to give the smallest time to determine an error status HW->SetAnalogOut(IoHardware::AMP_SIGNAL, 0.0); HW->WriteDigitalBit(IoHardware::MOTOR_ENABLE, MOTOR_OFF); HW->motorStatus = MOTOR_OFF; lost = 1; FATAL_ERROR("Frame not received -"); //strcpy(err_msg, "Frame not received -"); // // not work this way. } } attempt = 0; vnum[0] = -99; int n = VNET->Recv(); region = (int)vnum[0]; switch(region){ case 0: //ROI_0: obj.x0 = vnum[1]; //mm obj.y0 = vnum[2]; //mm break; case 1: //ROI_1: obj.x1 = vnum[1]; //mm obj.y1 = vnum[2]; //mm break; default: HW->SetAnalogOut(IoHardware::AMP_SIGNAL, 0.0); HW->WriteDigitalBit(IoHardware::MOTOR_ENABLE, MOTOR_OFF); HW->motorStatus = MOTOR_OFF; printf("roi-vnum[0]:%d\n", region); FATAL_ERROR("Object lost -"); lost = 1; } obj.x = (obj.x0 + obj.x1)/2/1000; // convert to m obj.y = (obj.y0 + obj.y1)/2/1000; double obj_raw_angle = atan2(obj.y1-obj.y0, obj.x1-obj.x0); // within -pi to pi // to keep continuous angle value when acrossing pi(or -pi). obj.theta = obj_raw_angle + obj_ang_index*2*3.141592; // converted angle if ( fabs(obj.theta - obj.theta_prev) > 3.141592 ) { if (obj.theta_prev > obj.theta) // pi to -pi region change obj_ang_index++; else obj_ang_index--; obj.theta = obj_raw_angle + obj_ang_index*2*3.141592; // newly converted angle } // calculation of the object angular velocity obj.angVel = (obj.theta - obj.theta_prev) / sec; // the use of SAMPLE_RATE may not be a big difference. // low pass filter double alpha = 0.038; //0.02 obj.angVel = alpha*obj.angVel + (1-alpha)*obj.angVel_prev; // calculation of the hand angular velocity handTheta = -(HW->GetEncoderCount(IoHardware::ENC_0)) * ENC_RAD_PER_CNT / GR / 4; // just access the data previously read by GetEnc...() handVel = (handTheta - handTheta_prev) /sec; //* SAMPLE_RATE; handVel = alpha*handVel + (1-alpha)*handVel_prev; // calculation of sh and \dot sh (=shD) sh = (obj.theta - handTheta) / K_R; eta2 = asin(-(obj.x-OBJ_X_OFFSET)/(RHO_H+RHO_O)); // alternative way to get eta2; /// test, eta2 compensation //eta2 = eta2 - 0.004*sin(obj.theta + 1.885); // new method for shD, thus eta1 feedback eta2D = (eta2 - eta2_prev) / sec; eta2D = alpha*eta2D + (1-alpha)*eta2D_prev; shD = RHO_H*(eta2D - handVel); eta1 = M22*shD + M12*handVel; /*************************************************************/ // calculation of the control input (acceleration command) eta1Bar = eta1 - COEFF_ETA1_STAR; z = handVel - TARGET_THETAHD; if (eta2 == 0) { u = -GAIN_K1*eta1Bar; } else { u = -GAIN_K1*eta1Bar*sin(eta2)/eta2 - GAIN_K2*eta2; } alpha = (u - COEFF_sig2*eta1Bar)/COEFF_sig3; if (eta2 == 0) { DuDeta1Bar = -GAIN_K1; DuDeta2 = -GAIN_K2; } else { DuDeta1Bar = -GAIN_K1*sin(eta2)/eta2; DuDeta2 = -GAIN_K1*eta1Bar*( (cos(eta2)*eta2 - sin(eta2))/(eta2*eta2) ) - GAIN_K2; } DalphaDeta1Bar = (DuDeta1Bar - COEFF_sig2)/COEFF_sig3; DalphaDeta2 = DuDeta2/COEFF_sig3; vInp = DalphaDeta1Bar*COEFF_sig1*sin(eta2) + DalphaDeta2*(COEFF_sig2*eta1Bar+COEFF_sig3*z) - eta2*COEFF_sig3 - GAIN_C*(z - alpha); /*************************************************************/ aCmd = vInp; // calculated acceleration command obj.theta_prev = obj.theta; obj.angVel_prev = obj.angVel; handTheta_prev = handTheta; handVel_prev = handVel; eta2D_prev = eta2D; eta2_prev = eta2; } else { // Because the vision system keeps sending the data, QNX must read them, otherwise the vision system will get a send error. VNET->Process(); } // test if (fabs(handVel) > 7.0 ) {//rad/sec HW->SetAnalogOut(IoHardware::AMP_SIGNAL, 0.0); HW->WriteDigitalBit(IoHardware::MOTOR_ENABLE, MOTOR_OFF); HW->motorStatus = MOTOR_OFF; //VNET->Process(); FATAL_ERROR("MOTOR RUNS TOO FAST"); lost = 1; } //************************************************************** // reading & calculating output // // feedback cycle = ClockCycles(); elapsedSec = (double)(cycle - cycle_prev)/cps; cycle_prev = cycle; //HW->ProcessInput(); // because of the encoder reading. Do not use this again. This takes a long time. enc = -(HW->ReadEncoder(IoHardware::ENC_0)); // direct read. Not working? pos = (enc * ENC_RAD_PER_CNT) / GR / 4; // convert to rad. GR:gear ratio (50). 4? vel = (pos - pos_prev) / elapsedSec; // to calculate more exact velocity. // This is necessary for not having motor run unexpectedly when swtiching from motor off to motor on. if(HW->motorStatus == MOTOR_ON) { cnt++; // acceleration inner loop // Notice that using no filtering velocity vCmd = vCmd_prev + aCmd / SAMPLE_RATE; pCmd = pCmd_prev + vCmd_prev / SAMPLE_RATE + 0.5 * aCmd / (SAMPLE_RATE*SAMPLE_RATE); iCmd = calcI(vCmd, aCmd); // feedforward control. feedforwardVal = iCmd; //iCmd += (150* (pCmd - pos) + 0.6 * (vCmd - vel) + Ki * error); // Ki 0 //iCmd += (200* (pCmd - pos) + 0.6 * (vCmd - vel) + Ki * error); // Ki 0 //iCmd += (350* (pCmd - pos) + 1.0 * (vCmd - vel) + Ki * error); // Ki 0 iCmd += (150* (pCmd - pos) + 0.9 * (vCmd - vel) + Ki * error); // Ki 0 pos_prev = pos; pCmd_prev = pCmd; vCmd_prev = vCmd; } else { iCmd = 0; } //************************************************** //************************************************** // control output // //limit current based on motor specs if(iCmd > (MAX_CURRENT_MA) ){ // 1.6 mA HW->SetAnalogOut(IoHardware::AMP_SIGNAL, 0.0); HW->WriteDigitalBit(IoHardware::MOTOR_ENABLE, MOTOR_OFF); HW->motorStatus = MOTOR_OFF; //VNET->Process(); printf("iCmd:%f, pCmd:%f, pos:%f, vCmd:%f, vel:%f, aCmd:%f feedforwardVal:%f cnt:%d\n", iCmd, pCmd, pos, vCmd, vel, aCmd, feedforwardVal, cnt); FATAL_ERROR("MOTOR CURRENT TOO HIGH"); lost = 1; iCmd = MAX_CURRENT_MA; } else if(iCmd < (-MAX_CURRENT_MA) ){ HW->SetAnalogOut(IoHardware::AMP_SIGNAL, 0.0); HW->WriteDigitalBit(IoHardware::MOTOR_ENABLE, MOTOR_OFF); HW->motorStatus = MOTOR_OFF; //VNET->Process(); printf("iCmd:%f, pCmd:%f, pos:%f, vCmd:%f, vel:%f, aCmd:%f feedforwardVal:%f cnt:%d%f\n", iCmd, pCmd, pos, vCmd, vel, aCmd, feedforwardVal, cnt); FATAL_ERROR("MOTOR CURRENT TOO HIGH"); lost = 1; iCmd = -MAX_CURRENT_MA; } ampVCmd =-iCmd * AMP_GAIN; // convert to analog signal. +-10 V. -0.86 for 4.5 rad/s. for test use -0.8 // sign change to agree with camera // output signal to amp if(!done){ HW->WriteAnalogCh(IoHardware::AMP_SIGNAL, ampVCmd); //HW->WriteAnalogCh(IoHardware::AMP_SIGNAL, 0.0); } else{ HW->WriteAnalogCh(IoHardware::AMP_SIGNAL, 0.0); } //******************************************************* //************************************************** HW->ProcessOutput(); // all digital & analog writing. // set outputs /*num[0] = obj.theta; num[1] = obj.angVel; */ num[0] = vInp;//obj.theta; //vInp; //correctedAcc; //eta1; //handVel; //pos; //handTheta; //pos; // angle in rad num[1] = eta1;//obj.angVel; //eta1; //feedforwardVal; //pCmd; //eta2; //obj.theta; //vnum[0]; //obj.theta; //vel; //obj.theta; num[2] = pos; //feedbackVal; //vCmd; //obj.angVel; //obj.x; //vnum[1]; //obj.x1; //ampVCmd; //obj.x1; // position in m, *10 for cm num[3] = eta2; //handTheta; //iCmd; //sec; //elapsedSec; //sec; //vnum[2]; //obj.y1; MNET->Process(); } // while() // for some reason, this does not work. HW->SetAnalogOut(IoHardware::AMP_SIGNAL, 0.0); HW->WriteDigitalBit(IoHardware::MOTOR_ENABLE, MOTOR_OFF); HW->motorStatus = MOTOR_OFF; delay(10); FATAL_ERROR(err_msg); }
OCLAcceleratorMatrixCOO<ValueType>::OCLAcceleratorMatrixCOO() { // no default constructors FATAL_ERROR(__FILE__, __LINE__); }
static bool ParseFile(FILE *pFile) { uint8_t size; if(pFile == NULL) { FATAL_ERROR(); return false; } fread(&size, sizeof(char), 1, pFile); fread(room.title, sizeof(char), size, pFile); room.title[size] = '\0'; fread(&size, sizeof(char), 1, pFile); if(size == 0) { room.itemRequirements = 0; } else { fread(&room.itemRequirements, sizeof(char), size, pFile); } while(!FindInInventory(room.itemRequirements) || room.itemRequirements) { fread(&size, sizeof(char), 1, pFile); fseek(pFile, size, SEEK_CUR); fread(&size, sizeof(char), 1, pFile); fread(&room.itemsContained, sizeof(char), size, pFile); fseek(pFile, 4, SEEK_CUR); fread(&size, sizeof(char), 1, pFile); if(size == 0) { room.itemRequirements = 0; } else { fread(&room.itemRequirements, sizeof(char), size, pFile); } } fread(&size, sizeof(char), 1, pFile); fread(room.description, sizeof(char), size, pFile); room.description[size] = '\0'; fread(&size, sizeof(char), 1, pFile); if(size != 0) { fread(&room.itemsContained, sizeof(char), size, pFile); AddToInventory(room.itemsContained); } else { room.itemsContained = 0; } fread(&room.north, sizeof(uint8_t), 1, pFile); fread(&room.east, sizeof(uint8_t), 1, pFile); fread(&room.south, sizeof(uint8_t), 1, pFile); fread(&room.west, sizeof(uint8_t), 1, pFile); room.roomExits = 0; if(room.north) { room.roomExits |= GAME_ROOM_EXIT_NORTH_EXISTS; } if(room.east) { room.roomExits |= GAME_ROOM_EXIT_NORTH_EXISTS; } if(room.south) { room.roomExits |= GAME_ROOM_EXIT_SOUTH_EXISTS; } if(room.west) { room.roomExits |= GAME_ROOM_EXIT_WEST_EXISTS; } fclose(pFile); return true; }
void load_conf(void) { FILE *fc; char line[128]; char *p, *q, **tmp; int lineno = 0; struct conf_entry *curr_section = NULL; void *value = NULL; /* initialize the structures */ init_structures(); DEBUG_MSG("load_conf"); /* the user has specified an alternative config file */ if (GBL_CONF->file) { DEBUG_MSG("load_conf: alternative config: %s", GBL_CONF->file); fc = fopen(GBL_CONF->file, FOPEN_READ_TEXT); ON_ERROR(fc, NULL, "Cannot open %s", GBL_CONF->file); } else { /* errors are handled by the function */ fc = open_data("etc", ETTER_CONF, FOPEN_READ_TEXT); ON_ERROR(fc, NULL, "Cannot open %s", ETTER_CONF); } /* read the file */ while (fgets(line, 128, fc) != 0) { /* update the line count */ lineno++; /* trim out the comments */ if ((p = strchr(line, '#'))) *p = '\0'; /* trim out the new line */ if ((p = strchr(line, '\n'))) *p = '\0'; q = line; /* trim the initial spaces */ while (q < line + sizeof(line) && *q == ' ') q++; /* skip empty lines */ if (line[0] == '\0' || *q == '\0') continue; /* here starts a new section [...] */ if (*q == '[') { /* remove the square brackets */ if ((p = strchr(line, ']'))) *p = '\0'; else FATAL_ERROR("Missing ] in %s line %d", ETTER_CONF, lineno); p = q + 1; DEBUG_MSG("load_conf: SECTION: %s", p); /* get the pointer to the right structure */ if ( (curr_section = search_section(p)) == NULL) FATAL_ERROR("Invalid section in %s line %d", ETTER_CONF, lineno); /* read the next line */ continue; } /* variable outside a section */ if (curr_section == NULL) FATAL_ERROR("Entry outside a section in %s line %d", ETTER_CONF, lineno); /* sanity check */ if (!strchr(q, '=')) FATAL_ERROR("Parse error %s line %d", ETTER_CONF, lineno); p = q; /* split the entry name from the value */ do { if (*p == ' ' || *p == '=') { *p = '\0'; break; } } while (p++ < line + sizeof(line) ); /* move p to the value */ p++; do { if (*p != ' ' && *p != '=') break; } while (p++ < line + sizeof(line) ); /* * if it is the "dissector" section, * do it in a different way */ if (curr_section == (struct conf_entry *)&dissectors) { set_dissector(q, p, lineno); continue; } /* search the entry name */ if ( (value = search_entry(curr_section, q)) == NULL) FATAL_ERROR("Invalid entry in %s line %d", ETTER_CONF, lineno); /* strings must be handled in a different way */ if (curr_section == (struct conf_entry *)&strings) { /* trim the quotes */ if (*p == '\"') p++; /* set the string value */ tmp = (char **)value; *tmp = strdup(p); /* trim the ending quotes */ p = *tmp; do { if (*p == '\"') *p = 0; } while (p++ < *tmp + strlen(*tmp) ); DEBUG_MSG("load_conf: \tENTRY: %s [%s]", q, *tmp); } else { /* set the integer value */ *(int *)value = strtol(p, (char **)NULL, 10); DEBUG_MSG("load_conf: \tENTRY: %s %d", q, *(int *)value); } } fclose(fc); }
/* * Each processor: * owns a set of pins (nonzeros) * may provide some edge weights * * We assume that no two processes will supply the same pin. * But more than one process may supply pins for the same edge. */ static int matrix_get_edges(ZZ *zz, Zoltan_matrix *matrix, ZOLTAN_ID_PTR *yGID, ZOLTAN_ID_PTR *pinID, int nX, ZOLTAN_ID_PTR *xGID, ZOLTAN_ID_PTR *xLID, int **xGNO, float **xwgt) { static char *yo = "Zoltan_Matrix_Build"; int ierr = ZOLTAN_OK; int hypergraph_callbacks = 0, graph_callbacks = 0; int *nbors_proc = NULL; /* Pointers are global for the function to ensure proper free */ int *edgeSize = NULL; ZOLTAN_TRACE_ENTER(zz, yo); if (zz->Get_HG_Size_CS && zz->Get_HG_CS) { hypergraph_callbacks = 1; } if ((zz->Get_Num_Edges != NULL || zz->Get_Num_Edges_Multi != NULL) && (zz->Get_Edge_List != NULL || zz->Get_Edge_List_Multi != NULL)) { graph_callbacks = 1; } if (graph_callbacks && hypergraph_callbacks){ /* if (hgraph_model == GRAPH) */ /* hypergraph_callbacks = 0; */ graph_callbacks = 1; /* I prefer graph (allow to do "inplace") ! */ } if (hypergraph_callbacks) { matrix->redist = 1; if (matrix->opts.speed == MATRIX_FULL_DD) ZOLTAN_FREE(xGID); else *xGID = NULL; ZOLTAN_FREE(xLID); ZOLTAN_FREE(xGNO); ierr = Zoltan_Hypergraph_Queries(zz, &matrix->nY, &matrix->nPins, yGID, &matrix->ystart, pinID); CHECK_IERR; matrix->yend = matrix->ystart + 1; } else if (graph_callbacks) { int max_edges = 0; int vertex; int numGID, numLID; matrix->opts.enforceSquare = 1; matrix->nY = nX; /* It is square ! */ matrix->yGNO = *xGNO; *xGNO = NULL; *yGID = NULL; matrix->ywgtdim = zz->Obj_Weight_Dim; *xwgt = NULL; numGID = zz->Num_GID; numLID = zz->Num_LID; /* TODO : support local graphs */ /* TODO : support weights ! */ /* Get edge data */ Zoltan_Get_Num_Edges_Per_Obj(zz, matrix->nY, *xGID, *xLID, &edgeSize, &max_edges, &matrix->nPins); (*pinID) = ZOLTAN_MALLOC_GID_ARRAY(zz, matrix->nPins); nbors_proc = (int *)ZOLTAN_MALLOC(matrix->nPins * sizeof(int)); if (matrix->nPins && ((*pinID) == NULL || nbors_proc == NULL)) MEMORY_ERROR; matrix->pinwgt = (float*)ZOLTAN_MALLOC(matrix->nPins*matrix->pinwgtdim*sizeof(float)); if (matrix->nPins && matrix->pinwgtdim && matrix->pinwgt == NULL) MEMORY_ERROR; if (zz->Get_Edge_List_Multi) { zz->Get_Edge_List_Multi(zz->Get_Edge_List_Multi_Data, numGID, numLID, matrix->nY, *xGID, *xLID, edgeSize, (*pinID), nbors_proc, matrix->pinwgtdim, matrix->pinwgt, &ierr); } else { int edge; for (vertex = 0, edge = 0 ; vertex < matrix->nY ; ++vertex) { zz->Get_Edge_List(zz->Get_Edge_List_Data, numGID, numLID, (*xGID)+vertex*numGID, (*xLID)+vertex*numLID, (*pinID)+edge*numGID, nbors_proc+edge, matrix->pinwgtdim, matrix->pinwgt+edge*matrix->pinwgtdim, &ierr); edge += edgeSize[vertex]; } } CHECK_IERR; /* Not Useful anymore */ ZOLTAN_FREE(xLID); if (matrix->opts.speed == MATRIX_FULL_DD) ZOLTAN_FREE(xGID); else *xGID = NULL; ZOLTAN_FREE(&nbors_proc); /* Now construct CSR indexing */ matrix->ystart = (int*) ZOLTAN_MALLOC((matrix->nY+1)*sizeof(int)); if (matrix->ystart == NULL) MEMORY_ERROR; matrix->ystart[0] = 0; matrix->yend = matrix->ystart + 1; for (vertex = 0 ; vertex < matrix->nY ; ++vertex) matrix->ystart[vertex+1] = matrix->ystart[vertex] + edgeSize[vertex]; } else { FATAL_ERROR ("You have to define Hypergraph or Graph queries"); } if (matrix->opts.enforceSquare) { matrix->globalY = matrix->globalX; matrix->ddY = matrix->ddX; matrix->ywgtdim = zz->Obj_Weight_Dim; } End: ZOLTAN_FREE(&edgeSize); ZOLTAN_FREE(&nbors_proc); ZOLTAN_FREE(xLID); ZOLTAN_FREE(xGID); ZOLTAN_FREE(xGNO); ZOLTAN_FREE(xwgt); ZOLTAN_TRACE_EXIT(zz, yo); return (ierr); }
/** * This function calls ButtonsCheckEvents() once per call and returns which, if any, * of the Morse code events listed in the enum above have been encountered. It checks for BTN4 * events in its input and should be called at 100Hz so that the timing works. The * length that BTN4 needs to be held down for a dot is >= 0.25s and < 0.50s with a dash being a button * down event for >= 0.5s. The button uptime various between dots/dashes (>= .5s), letters * (>= 1s), and words (>= 2s). * * @note This function assumes that the buttons are all unpressed at startup, so that the first * event it will see is a BUTTON_EVENT_*DOWN. * * So pressing the button for 0.1s, releasing it for 0.1s, pressing it for 0.3s, and then waiting * will decode the string '.-' (A). It will trigger the following order of events: * 9 MORSE_EVENT_NONEs, 1 MORSE_EVENT_DOT, 39 MORSE_EVENT_NONEs, a MORSE_EVENT_DASH, 69 * MORSE_EVENT_NONEs, a MORSE_EVENT_END_CHAR, and then MORSE_EVENT_INTER_WORDs. * * @return The MorseEvent that occurred. */ MorseEvent MorseCheckEvents(void) { switch (myState) { case(WAITING): {// if in the state of waiting if (ButtonsCheckEvents() == BUTTON_EVENT_4DOWN) { myState = DOT; myCount = 0; } return MORSE_EVENT_NONE; break; } case(DOT): { // in the state of dot myCount += 1; if (myCount >= MORSE_EVENT_LENGTH_DOWN_DOT) { myState = DASH; } if (ButtonsCheckEvents() == BUTTON_EVENT_4UP) { // Chenge into Inter letter myState = INTER_LETTER; myCount = 0; return MORSE_EVENT_DOT; } return MORSE_EVENT_NONE; break; } case(DASH): { //in Dash state if (ButtonsCheckEvents() == BUTTON_EVENT_4UP) { // change my state to Inter letter myState = INTER_LETTER; myCount = 0; return MORSE_EVENT_DASH; } return MORSE_EVENT_NONE; break; } case(INTER_LETTER): { //In the inter letter state myCount += 1; if (myCount > MORSE_EVENT_LENGTH_UP_INTER_WORD) { //if inter letter time out, we go to myState = WAITING; return MORSE_EVENT_INTER_WORD; } else if (ButtonsCheckEvents() == BUTTON_EVENT_4DOWN) { // if (myCount > MORSE_EVENT_LENGTH_UP_INTER_LETTER) { myCount = 0; myState = DOT; // return inter ltter event return MORSE_EVENT_INTER_LETTER; } myCount = 0; myState = DOT; } return MORSE_EVENT_NONE; break; } default: { //In the deflaut state FATAL_ERROR(); break; } } }
int main(void) { // Watchdog Timer Enabled/disabled by user software // (LPRC can be disabled by clearing SWDTEN bit in RCON registe // Configure Oscillator to operate the device at 40Mhz // Fosc= Fin*M/(N1*N2), Fcy=Fosc/2 // Fosc= 8M*40/(2*2)=80Mhz for 8M input clock PLLFBD = 38; // M=40 CLKDIVbits.PLLPOST = 0; // N1=2 CLKDIVbits.PLLPRE = 0; // N2=2 OSCTUN = 0; // Tune FRC oscillator, if FRC is used RCONbits.SWDTEN = 0; /* Disable Watch Dog Timer*/ // Clock switch to incorporate PLL __builtin_write_OSCCONH(0x03); // Initiate Clock Switch to Primary // Oscillator with PLL (NOSC=0b011) __builtin_write_OSCCONL(0x01); // Start clock switching while (OSCCONbits.COSC != 0b011); // Wait for Clock switch to occur while (OSCCONbits.LOCK != 1) { }; /* Wait for PLL to lock*/ // bufferPointer = NULL; Uart2Init(InterruptRoutine); if (!CB_Init(&circBuf, cbData, CB_SIZE)) FATAL_ERROR(); // Generate a fake input to record to the circular buffer // give beginning and end special characters unsigned char goodData[512]; int i; for (i=0; i<512; i++) { goodData[i] = (char)i; } goodSum = checksum(goodData, 512); Uart2PrintStr("Begin.\n"); file = NewSDInit("newfile.txt"); int SDConnected = 0; while(1) { // if (bufferPointer != NULL) { TODO implement this? // CB_WriteMany(&circBuf, bufferPointer, UART2_BUFFER_SIZE, 1); // the 1 is arbitrary // bufferPointer = NULL; // } if (SD_IN) { // if the board was just plugged in try to reinitialize if(!SDConnected) { MEDIA_INFORMATION * Minfo; do { Minfo = MDD_MediaInitialize(); } while(Minfo->errorCode == MEDIA_CANNOT_INITIALIZE); SDConnected = 1; } // When we are connected and initialized, poll the buffer, if there // is data, write it. unsigned char outData[SD_SECTOR_SIZE]; if (CB_PeekMany(&circBuf, outData, SD_SECTOR_SIZE)){ if(NewSDWriteSector(file, outData)){ // Remove the data we just written. if(checksum(outData, 512) != goodSum) { FATAL_ERROR(); } CB_Remove(&circBuf, SD_SECTOR_SIZE); } } } else { SDConnected = 0; } } }
/* * concatenate two (or more) files into one single file */ void concatenate(int argc, char **argv) { int zerr; gzFile fd; struct log_global_header hdr, tmp; memset(&hdr, 0, sizeof(struct log_global_header)); /* open the output file for writing */ fd = gzopen(GBL_LOGFILE, "wb"); ON_ERROR(fd, NULL, "%s", gzerror(fd, &zerr)); /* * use GBL_LOG_FD here so the get_header function * will use this file */ GBL_LOG_FD = gzopen(argv[argc], "rb"); ON_ERROR(GBL_LOG_FD, NULL, "%s", gzerror(GBL_LOG_FD, &zerr)); /* get the file header */ if (get_header(&hdr) != E_SUCCESS) FATAL_ERROR("Invalid log file (%s)", argv[argc]); /* write the header */ put_header(fd, &hdr); printf("Concatenating file [%s]", argv[argc]); /* copy the first file into the output */ dump_file(fd, &hdr); /* move the pointer to the next file */ argc++; /* cicle thru the file list */ while(argv[argc] != NULL) { GBL_LOG_FD = gzopen(argv[argc], "rb"); ON_ERROR(GBL_LOG_FD, NULL, "%s", gzerror(GBL_LOG_FD, &zerr)); /* get the file header */ if (get_header(&tmp) != E_SUCCESS) FATAL_ERROR("Invalid log file (%s)", argv[argc]); /* check if the files are compatible */ if (hdr.type != tmp.type) FATAL_ERROR("Cannot concatenate different type of file"); printf("Concatenating file [%s]", argv[argc]); /* concatenate this file */ dump_file(fd, &tmp); gzclose(GBL_LOG_FD); argc++; } gzclose(fd); printf("\nAll files concatenated into: %s\n\n", GBL_LOGFILE); exit(0); }
void initializePaths() { #if RUN_IN_PLACE char buf[BUFSIZ]; infostream << "Using relative paths (RUN_IN_PLACE)" << std::endl; bool success = getCurrentExecPath(buf, sizeof(buf)) || getExecPathFromProcfs(buf, sizeof(buf)); if (success) { pathRemoveFile(buf, DIR_DELIM_CHAR); std::string execpath(buf); path_share = execpath + DIR_DELIM ".."; path_user = execpath + DIR_DELIM ".."; if (detectMSVCBuildDir(execpath)) { path_share += DIR_DELIM ".."; path_user += DIR_DELIM ".."; } } else { errorstream << "Failed to get paths by executable location, " "trying cwd" << std::endl; if (!getCurrentWorkingDir(buf, sizeof(buf))) FATAL_ERROR("Ran out of methods to get paths"); size_t cwdlen = strlen(buf); if (cwdlen >= 1 && buf[cwdlen - 1] == DIR_DELIM_CHAR) { cwdlen--; buf[cwdlen] = '\0'; } if (cwdlen >= 4 && !strcmp(buf + cwdlen - 4, DIR_DELIM "bin")) pathRemoveFile(buf, DIR_DELIM_CHAR); std::string execpath(buf); path_share = execpath; path_user = execpath; } path_cache = path_user + DIR_DELIM + "cache"; #else infostream << "Using system-wide paths (NOT RUN_IN_PLACE)" << std::endl; if (!setSystemPaths()) errorstream << "Failed to get one or more system-wide path" << std::endl; // Initialize path_cache // First try $XDG_CACHE_HOME/PROJECT_NAME const char *cache_dir = getenv("XDG_CACHE_HOME"); const char *home_dir = getenv("HOME"); if (cache_dir) { path_cache = std::string(cache_dir) + DIR_DELIM + PROJECT_NAME; } else if (home_dir) { // Then try $HOME/.cache/PROJECT_NAME path_cache = std::string(home_dir) + DIR_DELIM + ".cache" + DIR_DELIM + PROJECT_NAME; } else { // If neither works, use $PATH_USER/cache path_cache = path_user + DIR_DELIM + "cache"; } // Migrate cache folder to new location if possible migrateCachePath(); #endif infostream << "Detected share path: " << path_share << std::endl; infostream << "Detected user path: " << path_user << std::endl; infostream << "Detected cache path: " << path_cache << std::endl; #if USE_GETTEXT bool found_localedir = false; # ifdef STATIC_LOCALEDIR if (STATIC_LOCALEDIR[0] && fs::PathExists(STATIC_LOCALEDIR)) { found_localedir = true; path_locale = STATIC_LOCALEDIR; infostream << "Using locale directory " << STATIC_LOCALEDIR << std::endl; } else { path_locale = getDataPath("locale"); if (fs::PathExists(path_locale)) { found_localedir = true; infostream << "Using in-place locale directory " << path_locale << " even though a static one was provided " << "(RUN_IN_PLACE or CUSTOM_LOCALEDIR)." << std::endl; } } # else path_locale = getDataPath("locale"); if (fs::PathExists(path_locale)) { found_localedir = true; } # endif if (!found_localedir) { warningstream << "Couldn't find a locale directory!" << std::endl; } #endif // USE_GETTEXT }
void parse_options(int argc, char **argv) { int c; static struct option long_options[] = { { "help", no_argument, NULL, 'h' }, { "version", no_argument, NULL, 'v' }, { "iface", required_argument, NULL, 'i' }, { "iflist", no_argument, NULL, 'I' }, { "netmask", required_argument, NULL, 'n' }, { "write", required_argument, NULL, 'w' }, { "read", required_argument, NULL, 'r' }, { "pcapfilter", required_argument, NULL, 'f' }, { "reversed", no_argument, NULL, 'R' }, { "proto", required_argument, NULL, 't' }, { "plugin", required_argument, NULL, 'P' }, { "filter", required_argument, NULL, 'F' }, { "superquiet", no_argument, NULL, 'Q' }, { "quiet", no_argument, NULL, 'q' }, { "script", required_argument, NULL, 's' }, { "silent", no_argument, NULL, 'z' }, { "unoffensive", no_argument, NULL, 'u' }, { "load-hosts", required_argument, NULL, 'j' }, { "save-hosts", required_argument, NULL, 'k' }, { "wep-key", required_argument, NULL, 'W' }, { "config", required_argument, NULL, 'a' }, { "dns", no_argument, NULL, 'd' }, { "regex", required_argument, NULL, 'e' }, { "visual", required_argument, NULL, 'V' }, { "ext-headers", no_argument, NULL, 'E' }, { "log", required_argument, NULL, 'L' }, { "log-info", required_argument, NULL, 'l' }, { "log-msg", required_argument, NULL, 'm' }, { "compress", no_argument, NULL, 'c' }, { "text", no_argument, NULL, 'T' }, { "curses", no_argument, NULL, 'C' }, { "gtk", no_argument, NULL, 'G' }, { "daemon", no_argument, NULL, 'D' }, { "mitm", required_argument, NULL, 'M' }, { "only-mitm", no_argument, NULL, 'o' }, { "bridge", required_argument, NULL, 'B' }, { "promisc", no_argument, NULL, 'p' }, { 0 , 0 , 0 , 0} }; #ifdef HAVE_GTK if (strcmp(argv[0], "ettercap-gtk") == 0) select_gtk_interface(); #endif #ifdef HAVE_NCURSES if (strcmp(argv[0], "ettercap-curses") == 0) select_curses_interface(); #endif if (strcmp(argv[0], "ettercap-text") == 0) select_text_interface(); for (c = 0; c < argc; c++) DEBUG_MSG("parse_options -- [%d] [%s]", c, argv[c]); /* OPTIONS INITIALIZATION */ GBL_PCAP->promisc = 1; GBL_FORMAT = &ascii_format; /* OPTIONS INITIALIZED */ optind = 0; while ((c = getopt_long (argc, argv, "a:B:CchDdEe:F:f:GhIi:j:k:L:l:M:m:n:oP:pQqiRr:s:Tt:UuV:vW:w:z", long_options, (int *)0)) != EOF) { switch (c) { case 'M': GBL_OPTIONS->mitm = 1; if (mitm_set(optarg) != ESUCCESS) FATAL_ERROR("MITM method '%s' not supported...\n", optarg); break; case 'o': GBL_OPTIONS->only_mitm = 1; //select_text_interface(); break; case 'B': GBL_OPTIONS->iface_bridge = strdup(optarg); set_bridge_sniff(); break; case 'p': GBL_PCAP->promisc = 0; break; case 'T': select_text_interface(); break; case 'C': #ifdef HAVE_NCURSES select_curses_interface(); #else fprintf(stdout, "\nncurses-interface not supported.\n\n"); clean_exit(-1); #endif break; case 'G': #ifdef HAVE_GTK select_gtk_interface(); #else fprintf(stdout, "\nGTK-Interface not supported.\n\n"); clean_exit(-1); #endif break; case 'D': select_daemon_interface(); break; case 'R': GBL_OPTIONS->reversed = 1; break; case 't': GBL_OPTIONS->proto = strdup(optarg); break; case 'P': /* user has requested the list */ if (!strcasecmp(optarg, "list")) { plugin_list(); clean_exit(0); } /* else set the plugin */ GBL_OPTIONS->plugin = strdup(optarg); break; case 'i': GBL_OPTIONS->iface = strdup(optarg); break; case 'I': /* this option is only useful in the text interface */ select_text_interface(); GBL_OPTIONS->iflist = 1; break; case 'n': GBL_OPTIONS->netmask = strdup(optarg); break; case 'r': /* we don't want to scan the lan while reading from file */ GBL_OPTIONS->silent = 1; GBL_OPTIONS->read = 1; GBL_OPTIONS->pcapfile_in = strdup(optarg); break; case 'w': GBL_OPTIONS->write = 1; GBL_OPTIONS->pcapfile_out = strdup(optarg); break; case 'f': GBL_PCAP->filter = strdup(optarg); break; case 'F': if (filter_load_file(optarg, GBL_FILTERS) != ESUCCESS) FATAL_ERROR("Cannot load filter file \"%s\"", optarg); break; case 'L': if (set_loglevel(LOG_PACKET, optarg) == -EFATAL) clean_exit(-EFATAL); break; case 'l': if (set_loglevel(LOG_INFO, optarg) == -EFATAL) clean_exit(-EFATAL); break; case 'm': if (set_msg_loglevel(LOG_TRUE, optarg) == -EFATAL) clean_exit(-EFATAL); break; case 'c': GBL_OPTIONS->compress = 1; break; case 'e': if (set_regex(optarg) == -EFATAL) clean_exit(-EFATAL); break; case 'Q': GBL_OPTIONS->superquiet = 1; /* no break, quiet must be enabled */ case 'q': GBL_OPTIONS->quiet = 1; break; case 's': GBL_OPTIONS->script = strdup(optarg); break; case 'z': GBL_OPTIONS->silent = 1; break; case 'u': GBL_OPTIONS->unoffensive = 1; break; case 'd': GBL_OPTIONS->resolve = 1; break; case 'j': GBL_OPTIONS->silent = 1; GBL_OPTIONS->load_hosts = 1; GBL_OPTIONS->hostsfile = strdup(optarg); break; case 'k': GBL_OPTIONS->save_hosts = 1; GBL_OPTIONS->hostsfile = strdup(optarg); break; case 'V': if (set_format(optarg) != ESUCCESS) clean_exit(-EFATAL); break; case 'E': GBL_OPTIONS->ext_headers = 1; break; case 'W': set_wep_key(optarg); break; case 'a': GBL_CONF->file = strdup(optarg); break; case 'h': ec_usage(); break; case 'v': printf("%s %s\n", GBL_PROGRAM, GBL_VERSION); clean_exit(0); break; case ':': // missing parameter fprintf(stdout, "\nTry `%s --help' for more options.\n\n", GBL_PROGRAM); clean_exit(-1); break; case '?': // unknown option fprintf(stdout, "\nTry `%s --help' for more options.\n\n", GBL_PROGRAM); clean_exit(-1); break; } } DEBUG_MSG("parse_options: options parsed"); /* TARGET1 and TARGET2 parsing */ if (argv[optind]) { GBL_OPTIONS->target1 = strdup(argv[optind]); DEBUG_MSG("TARGET1: %s", GBL_OPTIONS->target1); if (argv[optind+1]) { GBL_OPTIONS->target2 = strdup(argv[optind+1]); DEBUG_MSG("TARGET2: %s", GBL_OPTIONS->target2); } } /* create the list form the TARGET format (MAC/IPrange/PORTrange) */ compile_display_filter(); DEBUG_MSG("parse_options: targets parsed"); /* check for other options */ if (GBL_SNIFF->start == NULL) set_unified_sniff(); if (GBL_OPTIONS->read && GBL_PCAP->filter) FATAL_ERROR("Cannot read from file and set a filter on interface"); if (GBL_OPTIONS->read && GBL_SNIFF->type != SM_UNIFIED ) FATAL_ERROR("You can read from a file ONLY in unified sniffing mode !"); if (GBL_OPTIONS->mitm && GBL_SNIFF->type != SM_UNIFIED ) FATAL_ERROR("You can't do mitm attacks in bridged sniffing mode !"); if (GBL_SNIFF->type == SM_BRIDGED && GBL_PCAP->promisc == 0) FATAL_ERROR("During bridged sniffing the iface must be in promisc mode !"); if (GBL_OPTIONS->quiet && GBL_UI->type != UI_TEXT) FATAL_ERROR("The quiet option is useful only with text only UI"); if (GBL_OPTIONS->load_hosts && GBL_OPTIONS->save_hosts) FATAL_ERROR("Cannot load and save at the same time the hosts list..."); if (GBL_OPTIONS->unoffensive && GBL_OPTIONS->mitm) FATAL_ERROR("Cannot use mitm attacks in unoffensive mode"); if (GBL_OPTIONS->read && GBL_OPTIONS->mitm) FATAL_ERROR("Cannot use mitm attacks while reading from file"); if (GBL_UI->init == NULL) { FATAL_ERROR("Please select an User Interface"); } /* force text interface for only mitm attack */ //if (GBL_OPTIONS->only_mitm) { // if (GBL_OPTIONS->mitm) // select_text_interface(); // else // FATAL_ERROR("Only mitm requires at least one mitm method"); //} DEBUG_MSG("parse_options: options combination looks good"); return; }
void OCLAcceleratorMatrixCOO<ValueType>::CopyTo(BaseMatrix<ValueType> *dst) const { OCLAcceleratorMatrixCOO<ValueType> *ocl_cast_mat; HostMatrix<ValueType> *host_cast_mat; // copy only in the same format assert(this->get_mat_format() == dst->get_mat_format()); // OCL to OCL copy if ((ocl_cast_mat = dynamic_cast<OCLAcceleratorMatrixCOO<ValueType>*> (dst)) != NULL) { ocl_cast_mat->set_backend(this->local_backend_); if (this->get_nnz() == 0) ocl_cast_mat->AllocateCOO(dst->get_nnz(), dst->get_nrow(), dst->get_ncol() ); assert((this->get_nnz() == dst->get_nnz()) && (this->get_nrow() == dst->get_nrow()) && (this->get_ncol() == dst->get_ncol()) ); if (this->get_nnz() > 0) { // Copy object from device to device memory (internal copy) ocl_dev2dev<int>(this->get_nnz(), // size this->mat_.row, // src ocl_cast_mat->mat_.row, // dst OCL_HANDLE(this->local_backend_.OCL_handle)->OCL_cmdQueue ); // Copy object from device to device memory (internal copy) ocl_dev2dev<int>(this->get_nnz(), // size this->mat_.col, // src ocl_cast_mat->mat_.col, // dst OCL_HANDLE(this->local_backend_.OCL_handle)->OCL_cmdQueue ); // Copy object from device to device memory (internal copy) ocl_dev2dev<ValueType>(this->get_nnz(), // size this->mat_.val, // src ocl_cast_mat->mat_.val, // dst OCL_HANDLE(this->local_backend_.OCL_handle)->OCL_cmdQueue ); } } else { //OCL to CPU if ((host_cast_mat = dynamic_cast<HostMatrix<ValueType>*> (dst)) != NULL) { this->CopyToHost(host_cast_mat); } else { LOG_INFO("Error unsupported OCL matrix type"); this->info(); dst->info(); FATAL_ERROR(__FILE__, __LINE__); } } }
void PackedPayloadHashTable::resize(const std::size_t extra_buckets, const std::size_t extra_variable_storage, const std::size_t retry_num) { // A retry should never be necessary with this implementation of HashTable. // Separate chaining ensures that any resized hash table with more buckets // than the original table will be able to hold more entries than the // original. DEBUG_ASSERT(retry_num == 0); SpinSharedMutexExclusiveLock<true> write_lock(this->resize_shared_mutex_); // Recheck whether the hash table is still full. Note that multiple threads // might wait to rebuild this hash table simultaneously. Only the first one // should do the rebuild. if (!isFull(extra_variable_storage)) { return; } // Approximately double the number of buckets and slots. // // TODO(chasseur): It may be worth it to more than double the number of // buckets here so that we can maintain a good, sparse fill factor for a // longer time as more values are inserted. Such behavior should take into // account kHashTableLoadFactor. std::size_t resized_num_slots = get_next_prime_number( (header_->num_buckets + extra_buckets / 2) * kHashTableLoadFactor * 2); std::size_t variable_storage_required = (resized_num_slots / kHashTableLoadFactor) * key_manager_.getEstimatedVariableKeySize(); const std::size_t original_variable_storage_used = header_->variable_length_bytes_allocated.load(std::memory_order_relaxed); // If this resize was triggered by a too-large variable-length key, bump up // the variable-length storage requirement. if ((extra_variable_storage > 0) && (extra_variable_storage + original_variable_storage_used > key_manager_.getVariableLengthKeyStorageSize())) { variable_storage_required += extra_variable_storage; } const std::size_t resized_memory_required = sizeof(Header) + resized_num_slots * sizeof(std::atomic<std::size_t>) + (resized_num_slots / kHashTableLoadFactor) * bucket_size_ + variable_storage_required; const std::size_t resized_storage_slots = this->storage_manager_->SlotsNeededForBytes(resized_memory_required); if (resized_storage_slots == 0) { FATAL_ERROR( "Storage requirement for resized SeparateChainingHashTable " "exceeds maximum allocation size."); } // Get a new StorageBlob to hold the resized hash table. const block_id resized_blob_id = this->storage_manager_->createBlob(resized_storage_slots); MutableBlobReference resized_blob = this->storage_manager_->getBlobMutable(resized_blob_id); // Locate data structures inside the new StorageBlob. void *aligned_memory_start = resized_blob->getMemoryMutable(); std::size_t available_memory = resized_storage_slots * kSlotSizeBytes; if (align(alignof(Header), sizeof(Header), aligned_memory_start, available_memory) == nullptr) { // Should be impossible, as noted in constructor. FATAL_ERROR( "StorageBlob used to hold resized SeparateChainingHashTable " "is too small to meet alignment requirements of " "LinearOpenAddressingHashTable::Header."); } else if (aligned_memory_start != resized_blob->getMemoryMutable()) { // Again, should be impossible. DEV_WARNING("In SeparateChainingHashTable::resize(), StorageBlob " << "memory adjusted by " << (resized_num_slots * kSlotSizeBytes - available_memory) << " bytes to meet alignment requirement for " << "LinearOpenAddressingHashTable::Header."); } Header *resized_header = static_cast<Header *>(aligned_memory_start); aligned_memory_start = static_cast<char *>(aligned_memory_start) + sizeof(Header); available_memory -= sizeof(Header); // As in constructor, recompute the number of slots and buckets using the // actual available memory. std::size_t resized_num_buckets = (available_memory - extra_variable_storage) / (kHashTableLoadFactor * sizeof(std::atomic<std::size_t>) + bucket_size_ + key_manager_.getEstimatedVariableKeySize()); resized_num_slots = get_previous_prime_number(resized_num_buckets * kHashTableLoadFactor); resized_num_buckets = resized_num_slots / kHashTableLoadFactor; // Locate slot array. std::atomic<std::size_t> *resized_slots = static_cast<std::atomic<std::size_t> *>(aligned_memory_start); aligned_memory_start = static_cast<char *>(aligned_memory_start) + sizeof(std::atomic<std::size_t>) * resized_num_slots; available_memory -= sizeof(std::atomic<std::size_t>) * resized_num_slots; // As in constructor, we will be extra paranoid and use align() to locate the // start of the array of buckets, as well. void *resized_buckets = aligned_memory_start; if (align( kBucketAlignment, bucket_size_, resized_buckets, available_memory) == nullptr) { FATAL_ERROR( "StorageBlob used to hold resized SeparateChainingHashTable " "is too small to meet alignment requirements of buckets."); } else if (resized_buckets != aligned_memory_start) { DEV_WARNING( "Bucket array start position adjusted to meet alignment " "requirement for SeparateChainingHashTable's value type."); if (resized_num_buckets * bucket_size_ + variable_storage_required > available_memory) { --resized_num_buckets; } } aligned_memory_start = static_cast<char *>(aligned_memory_start) + resized_num_buckets * bucket_size_; available_memory -= resized_num_buckets * bucket_size_; void *resized_variable_length_key_storage = aligned_memory_start; const std::size_t resized_variable_length_key_storage_size = available_memory; const std::size_t original_buckets_used = header_->buckets_allocated.load(std::memory_order_relaxed); // Initialize the header. resized_header->num_slots = resized_num_slots; resized_header->num_buckets = resized_num_buckets; resized_header->buckets_allocated.store(original_buckets_used, std::memory_order_relaxed); resized_header->variable_length_bytes_allocated.store( original_variable_storage_used, std::memory_order_relaxed); // Bulk-copy buckets. This is safe because: // 1. The "next" pointers will be adjusted when rebuilding chains below. // 2. The hash codes will stay the same. // 3. For key components: // a. Inline keys will stay exactly the same. // b. Offsets into variable-length storage will remain valid, because // we also do a byte-for-byte copy of variable-length storage below. // c. Absolute external pointers will still point to the same address. // d. Relative pointers are not used with resizable hash tables. // 4. If values are not trivially copyable, then we invoke ValueT's copy // or move constructor with placement new. // NOTE(harshad) - Regarding point 4 above, as this is a specialized // hash table implemented for aggregation, the values are trivially copyable, // therefore we don't need to invoke payload values' copy/move constructors. std::memcpy(resized_buckets, buckets_, original_buckets_used * bucket_size_); // Copy over variable-length key components, if any. if (original_variable_storage_used > 0) { DEBUG_ASSERT(original_variable_storage_used == key_manager_.getNextVariableLengthKeyOffset()); DEBUG_ASSERT(original_variable_storage_used <= resized_variable_length_key_storage_size); std::memcpy(resized_variable_length_key_storage, key_manager_.getVariableLengthKeyStorage(), original_variable_storage_used); } destroyPayload(); // Make resized structures active. std::swap(this->blob_, resized_blob); header_ = resized_header; slots_ = resized_slots; buckets_ = resized_buckets; key_manager_.setVariableLengthStorageInfo( resized_variable_length_key_storage, resized_variable_length_key_storage_size, &(resized_header->variable_length_bytes_allocated)); // Drop the old blob. const block_id old_blob_id = resized_blob->getID(); resized_blob.release(); this->storage_manager_->deleteBlockOrBlobFile(old_blob_id); // Rebuild chains. void *current_bucket = buckets_; for (std::size_t bucket_num = 0; bucket_num < original_buckets_used; ++bucket_num) { std::atomic<std::size_t> *next_ptr = static_cast<std::atomic<std::size_t> *>(current_bucket); const std::size_t hash_code = *reinterpret_cast<const std::size_t *>( static_cast<const char *>(current_bucket) + sizeof(std::atomic<std::size_t>)); const std::size_t slot_number = hash_code % header_->num_slots; std::size_t slot_ptr_value = 0; if (slots_[slot_number].compare_exchange_strong( slot_ptr_value, bucket_num + 1, std::memory_order_relaxed)) { // This bucket is the first in the chain for this block, so reset its // next pointer to 0. next_ptr->store(0, std::memory_order_relaxed); } else { // A chain already exists starting from this slot, so put this bucket at // the head. next_ptr->store(slot_ptr_value, std::memory_order_relaxed); slots_[slot_number].store(bucket_num + 1, std::memory_order_relaxed); } current_bucket = static_cast<char *>(current_bucket) + bucket_size_; } }
int main(int argc, char *argv[]) { int ret; /* etterlog copyright */ globals_alloc(); fprintf(stdout, "\n" EC_COLOR_BOLD "%s %s" EC_COLOR_END " copyright %s %s\n\n", GBL_PROGRAM, EC_VERSION, EC_COPYRIGHT, EC_AUTHORS); /* allocate the global target */ SAFE_CALLOC(GBL_TARGET, 1, sizeof(struct target_env)); /* initialize to all target */ GBL_TARGET->all_mac = 1; GBL_TARGET->all_ip = 1; GBL_TARGET->all_port = 1; /* getopt related parsing... */ parse_options(argc, argv); /* get the global header */ ret = get_header(&GBL->hdr); if (ret == -EINVALID) FATAL_ERROR("Invalid log file"); fprintf(stderr, "Log file version : %s\n", GBL->hdr.version); /* display the date. ec_ctime() has no newline at end. */ fprintf(stderr, "Timestamp : %s [%lu]\n", ec_ctime(&GBL->hdr.tv), GBL->hdr.tv.tv_usec); fprintf(stderr, "Type : %s\n\n", (GBL->hdr.type == LOG_PACKET) ? "LOG_PACKET" : "LOG_INFO" ); /* analyze the logfile */ if (GBL->analyze) analyze(); /* rewind the log file and skip the global header */ gzrewind(GBL_LOG_FD); get_header(&GBL->hdr); /* create the connection table (respecting the filters) */ if (GBL->connections) conn_table_create(); /* display the connection table */ if (GBL->connections && !GBL->decode) conn_table_display(); /* extract files from the connections */ if (GBL->decode) conn_decode(); /* not interested in the content... only analysis */ if (GBL->analyze || GBL->connections) return 0; /* display the content of the logfile */ display(); globals_free(); return 0; }
static void read_directory_file (void) { char *strp; FILE *fp; char buf[512]; /* FIXME: use a symbol */ static char *path = NULL; if (path == NULL) path = xmalloc (PATH_MAX); time (&time_now); if (listed_incremental_option[0] != '/' #if DOSWIN /* The case of DOSWIN absolute file name with a drive letter. */ && !(listed_incremental_option[0] && listed_incremental_option[1] == ':') #endif ) { char *current_directory = xgetcwd (); if (!current_directory) FATAL_ERROR ((0, 0, _("Could not get current directory"))); listed_incremental_option = concat_with_slash (current_directory, listed_incremental_option); } fp = fopen (listed_incremental_option, "r"); if (fp == 0 && errno != ENOENT) { ERROR ((0, errno, _("Cannot open %s"), listed_incremental_option)); return; } if (!fp) return; fgets (buf, sizeof (buf), fp); /* FIXME: Using newer_ctime_option as a first time flag looks fairly dubious to me! So, using -N with incremental might be buggy just because of the next few lines. I saw a few unexplained, almost harsh advices from FSF people about *not* using -N with incremental dumps, and here might lie (part of) the reason. */ if (!newer_ctime_option) { time_option_threshold = atol (buf); newer_ctime_option = true; } while (fgets (buf, sizeof (buf), fp)) { dev_t device_number; ino_t inode_number; strp = &buf[strlen (buf)]; if (strp[-1] == '\n') strp[-1] = '\0'; /* FIXME: For files ending with an incomplete line, maybe a NUL might be missing, here... */ strp = buf; device_number = atol (strp); while (ISDIGIT (*strp)) strp++; inode_number = atol (strp); while (ISSPACE (*strp)) strp++; while (ISDIGIT (*strp)) strp++; strp++; unquote_string (strp); note_directory (strp, device_number, inode_number, NULL); } if (fclose (fp) == EOF) ERROR ((0, errno, "%s", listed_incremental_option)); }
void parse_options(int argc, char **argv) { int c; struct in_addr ip; static struct option long_options[] = { { "help", no_argument, NULL, 'h' }, { "version", no_argument, NULL, 'v' }, { "binary", no_argument, NULL, 'B' }, { "hex", no_argument, NULL, 'X' }, { "ascii", no_argument, NULL, 'A' }, { "text", no_argument, NULL, 'T' }, { "ebcdic", no_argument, NULL, 'E' }, { "html", no_argument, NULL, 'H' }, { "utf8", required_argument, NULL, 'U' }, { "zero", no_argument, NULL, 'Z' }, { "xml", no_argument, NULL, 'x' }, { "analyze", no_argument, NULL, 'a' }, { "connections", no_argument, NULL, 'c' }, { "filter", required_argument, NULL, 'f' }, { "filcon", required_argument, NULL, 'F' }, { "no-headers", no_argument, NULL, 'n' }, { "only-source", no_argument, NULL, 's' }, { "only-dest", no_argument, NULL, 'd' }, { "show-mac", no_argument, NULL, 'm' }, { "show-client", no_argument, NULL, 'i' }, { "color", no_argument, NULL, 'k' }, { "reverse", no_argument, NULL, 'r' }, { "proto", required_argument, NULL, 't' }, { "only-local", required_argument, NULL, 'l' }, { "only-remote", required_argument, NULL, 'L' }, { "outfile", required_argument, NULL, 'o' }, { "concat", no_argument, NULL, 'C' }, { "decode", no_argument, NULL, 'D' }, { "user", required_argument, NULL, 'u' }, { "regex", required_argument, NULL, 'e' }, { "passwords", no_argument, NULL, 'p' }, { "client", required_argument, NULL, 'I' }, { 0 , 0 , 0 , 0} }; optind = 0; while ((c = getopt_long (argc, argv, "AaBCcDdEe:F:f:HhiI:kLlmno:prsTt:U:u:vXxZ", long_options, (int *)0)) != EOF) { switch (c) { case 'a': GBL.analyze = 1; break; case 'c': GBL.connections = 1; break; case 'D': GBL.connections = 1; GBL.decode = 1; NOT_IMPLEMENTED(); break; case 'f': target_compile(optarg); break; case 'F': filcon_compile(optarg); break; case 's': GBL.only_source = 1; break; case 'd': GBL.only_dest = 1; break; case 'k': GBL.color = 1; break; case 'r': GBL.reverse = 1; break; case 't': GBL_TARGET->proto = strdup(optarg); break; case 'n': GBL.no_headers = 1; break; case 'm': GBL.showmac = 1; break; case 'i': GBL.showclient = 1; break; case 'I': if (inet_aton(optarg, &ip) == 0) { FATAL_ERROR("Invalid client ip address"); return; } ip_addr_init(&GBL.client, AF_INET, (u_char *)&ip); break; case 'l': GBL.only_local = 1; break; case 'L': GBL.only_remote = 1; break; case 'u': GBL.user = strdup(optarg); break; case 'p': GBL.passwords = 1; break; case 'e': set_display_regex(optarg); break; case 'o': GBL_LOGFILE = strdup(optarg); break; case 'C': GBL.concat = 1; break; case 'B': GBL.format = &bin_format; break; case 'X': GBL.format = &hex_format; break; case 'A': GBL.format = &ascii_format; break; case 'T': GBL.format = &text_format; break; case 'E': GBL.format = &ebcdic_format; break; case 'H': GBL.format = &html_format; break; case 'U': set_utf8_encoding((u_char*)optarg); GBL.format = &utf8_format; break; case 'Z': GBL.format = &zero_format; break; case 'x': GBL.xml = 1; break; case 'h': el_usage(); break; case 'v': printf("%s %s\n", GBL_PROGRAM, EC_VERSION); exit(0); break; case ':': // missing parameter fprintf(stdout, "\nTry `%s --help' for more options.\n\n", GBL_PROGRAM); exit(0); break; case '?': // unknown option fprintf(stdout, "\nTry `%s --help' for more options.\n\n", GBL_PROGRAM); exit(0); break; } } /* file concatenation */ if (GBL.concat) { if (argv[optind] == NULL) FATAL_ERROR("You MUST specify at least one logfile"); /* this function does not return */ concatenate(optind, argv); } /* normal file operation */ if (argv[optind]) open_log(argv[optind]); else FATAL_ERROR("You MUST specify a logfile\n"); /* default to ASCII view */ if (GBL.format == NULL) GBL.format = &ascii_format; return; }
void PlayerSAO::getStaticData(std::string *result) const { FATAL_ERROR("Deprecated function"); }
/** * * @author Petr Djakow */ void Utils::reuseSocketAddr(int sockfd) { int opt = 1; if(setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) == -1) FATAL_ERROR(("Could not reuse socket addr")); }
static void stdin_read_complete(GObject *src, GAsyncResult *res, gpointer data) { char *s, *ep; GError *err = NULL; gsize len; s = g_data_input_stream_read_line_finish(G_DATA_INPUT_STREAM(src), res, &len, &err); if (!s) { if (err) { FATAL_ERROR("Reading from stdin: %s\n", err->message); g_error_free(err); return; } switch (state) { case STATE_WAITING_FOR_BUS_N_DEV: FATAL_ERROR("EOF while waiting for bus and device num\n"); break; case STATE_WAITING_FOR_POL_KIT: ERROR("Cancelled while waiting for authorization\n"); break; case STATE_WAITING_FOR_STDIN_EOF: cleanup(); break; } return; } switch (state) { case STATE_WAITING_FOR_BUS_N_DEV: busnum = strtol(s, &ep, 10); if (!isspace(*ep)) { FATAL_ERROR("Invalid busnum / devnum: %s\n", s); break; } devnum = strtol(ep, &ep, 10); if (*ep != '\0') { FATAL_ERROR("Invalid busnum / devnum: %s\n", s); break; } /* * The set_facl() call is a no-op for root, so no need to ask PolKit * and then if ok call set_facl(), when called by a root process. */ if (getuid() != 0) { polkit_cancellable = g_cancellable_new(); polkit_authority_check_authorization( authority, subject, "org.spice-space.lowlevelusbaccess", NULL, POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION, polkit_cancellable, (GAsyncReadyCallback)check_authorization_cb, NULL); state = STATE_WAITING_FOR_POL_KIT; } else { fprintf(stdout, "SUCCESS\n"); fflush(stdout); state = STATE_WAITING_FOR_STDIN_EOF; } g_data_input_stream_read_line_async(stdin_stream, G_PRIORITY_DEFAULT, NULL, stdin_read_complete, NULL); break; default: FATAL_ERROR("Unexpected extra input in state %u: %s\n", state, s); } g_free(s); }
void info_attach_exclist (struct tar_stat_info *dir) { struct excfile *file; struct exclist *head = NULL, *tail = NULL, *ent; struct vcs_ignore_file *vcsfile; if (dir->exclude_list) return; for (file = excfile_head; file; file = file->next) { if (faccessat (dir ? dir->fd : chdir_fd, file->name, F_OK, 0) == 0) { FILE *fp; struct exclude *ex = NULL; int fd = subfile_open (dir, file->name, O_RDONLY); if (fd == -1) { open_error (file->name); continue; } fp = fdopen (fd, "r"); if (!fp) { ERROR ((0, errno, _("%s: fdopen failed"), file->name)); close (fd); continue; } if (!ex) ex = new_exclude (); vcsfile = get_vcs_ignore_file (file->name); if (vcsfile->initfn) vcsfile->data = vcsfile->initfn (vcsfile->data); if (add_exclude_fp (vcsfile->addfn, ex, fp, EXCLUDE_WILDCARDS|EXCLUDE_ANCHORED, '\n', vcsfile->data)) { int e = errno; FATAL_ERROR ((0, e, "%s", quotearg_colon (file->name))); } fclose (fp); ent = xmalloc (sizeof (*ent)); ent->excluded = ex; ent->flags = file->flags == EXCL_DEFAULT ? file->flags : vcsfile->flags; ent->prev = tail; ent->next = NULL; if (tail) tail->next = ent; else head = ent; tail = ent; } } dir->exclude_list = head; }
void LocalStencil<ValueType>::MoveToHost(void) { LOG_INFO("The function is not implemented (yet)!"); FATAL_ERROR(__FILE__, __LINE__); }
/** * @brief For Numeric TypeInstances, get this TypeInstance's value as a C++ * float. * @warning supportsNumericInterface() must be true and isNull() must be * false for this method to be usable. * * @return The value as a float. **/ virtual float numericGetFloatValue() const { FATAL_ERROR("Used a Numeric interface method on a non-numeric TypeInstance."); }
void initializePaths() { #if RUN_IN_PLACE /* Use relative paths if RUN_IN_PLACE */ infostream<<"Using relative paths (RUN_IN_PLACE)"<<std::endl; /* Windows */ #if defined(_WIN32) const DWORD buflen = 1000; char buf[buflen]; DWORD len; // Find path of executable and set path_share relative to it len = GetModuleFileName(GetModuleHandle(NULL), buf, buflen); assert(len < buflen); pathRemoveFile(buf, '\\'); if(detectMSVCBuildDir(buf)){ infostream<<"MSVC build directory detected"<<std::endl; path_share = std::string(buf) + "\\..\\.."; path_user = std::string(buf) + "\\..\\.."; } else{ path_share = std::string(buf) + "\\.."; path_user = std::string(buf) + "\\.."; } /* Linux */ #elif defined(linux) char buf[BUFSIZ]; memset(buf, 0, BUFSIZ); // Get path to executable FATAL_ERROR_IF(readlink("/proc/self/exe", buf, BUFSIZ-1) == -1, "Failed to get cwd"); pathRemoveFile(buf, '/'); path_share = std::string(buf) + "/.."; path_user = std::string(buf) + "/.."; /* OS X */ #elif defined(__APPLE__) CFBundleRef main_bundle = CFBundleGetMainBundle(); CFURLRef resources_url = CFBundleCopyResourcesDirectoryURL(main_bundle); char path[PATH_MAX]; if (CFURLGetFileSystemRepresentation(resources_url, TRUE, (UInt8 *)path, PATH_MAX)) { path_share = std::string(path); path_user = std::string(path) + "/../User"; } else { dstream << "WARNING: Could not determine bundle resource path" << std::endl; } CFRelease(resources_url); /* FreeBSD */ #elif defined(__FreeBSD__) int mib[4]; char buf[BUFSIZ]; size_t len = sizeof(buf); mib[0] = CTL_KERN; mib[1] = KERN_PROC; mib[2] = KERN_PROC_PATHNAME; mib[3] = -1; FATAL_ERROR_IF(sysctl(mib, 4, buf, &len, NULL, 0) == -1, ""); pathRemoveFile(buf, '/'); path_share = std::string(buf) + "/.."; path_user = std::string(buf) + "/.."; #else //TODO: Get path of executable. This assumes working directory is bin/ dstream<<"WARNING: Relative path not properly supported on this platform" <<std::endl; /* scriptapi no longer allows paths that start with "..", so assuming that the current working directory is bin/, strip off the last component. */ char *cwd = getcwd(NULL, 0); pathRemoveFile(cwd, '/'); path_share = std::string(cwd); path_user = std::string(cwd); #endif #else // RUN_IN_PLACE /* Use platform-specific paths otherwise */ infostream<<"Using system-wide paths (NOT RUN_IN_PLACE)"<<std::endl; /* Windows */ #if defined(_WIN32) const DWORD buflen = 1000; // FIXME: Surely there is a better way to do this char buf[buflen]; DWORD len; // Find path of executable and set path_share relative to it len = GetModuleFileName(GetModuleHandle(NULL), buf, buflen); FATAL_ERROR_IF(len >= buflen, "Overlow"); pathRemoveFile(buf, '\\'); // Use ".\bin\.." path_share = std::string(buf) + "\\.."; // Use "C:\Documents and Settings\user\Application Data\<PROJECT_NAME>" len = GetEnvironmentVariable("APPDATA", buf, buflen); FATAL_ERROR_IF(len >= buflen, "Overlow"); path_user = std::string(buf) + DIR_DELIM + lowercase(PROJECT_NAME); /* Linux */ #elif defined(linux) // Get path to executable std::string bindir = ""; { char buf[BUFSIZ]; memset(buf, 0, BUFSIZ); if (readlink("/proc/self/exe", buf, BUFSIZ-1) == -1) { errorstream << "Unable to read bindir "<< std::endl; #ifndef __ANDROID__ FATAL_ERROR("Unable to read bindir"); #endif } else { pathRemoveFile(buf, '/'); bindir = buf; } } // Find share directory from these. // It is identified by containing the subdirectory "builtin". std::list<std::string> trylist; std::string static_sharedir = STATIC_SHAREDIR; if(static_sharedir != "" && static_sharedir != ".") trylist.push_back(static_sharedir); trylist.push_back( bindir + DIR_DELIM + ".." + DIR_DELIM + "share" + DIR_DELIM + lowercase(PROJECT_NAME)); trylist.push_back(bindir + DIR_DELIM + ".."); #ifdef __ANDROID__ trylist.push_back(path_user); #endif for(std::list<std::string>::const_iterator i = trylist.begin(); i != trylist.end(); i++) { const std::string &trypath = *i; if(!fs::PathExists(trypath) || !fs::PathExists(trypath + DIR_DELIM + "builtin")){ dstream<<"WARNING: system-wide share not found at \"" <<trypath<<"\""<<std::endl; continue; } // Warn if was not the first alternative if(i != trylist.begin()){ dstream<<"WARNING: system-wide share found at \"" <<trypath<<"\""<<std::endl; } path_share = trypath; break; } #ifndef __ANDROID__ path_user = std::string(getenv("HOME")) + DIR_DELIM + "." + lowercase(PROJECT_NAME); #endif /* OS X */ #elif defined(__APPLE__) CFBundleRef main_bundle = CFBundleGetMainBundle(); CFURLRef resources_url = CFBundleCopyResourcesDirectoryURL(main_bundle); char path[PATH_MAX]; if (CFURLGetFileSystemRepresentation(resources_url, TRUE, (UInt8 *)path, PATH_MAX)) { path_share = std::string(path); } else { dstream << "WARNING: Could not determine bundle resource path" << std::endl; } CFRelease(resources_url); path_user = std::string(getenv("HOME")) + "/Library/Application Support/" + lowercase(PROJECT_NAME); #else // FreeBSD, and probably many other POSIX-like systems. path_share = STATIC_SHAREDIR; path_user = std::string(getenv("HOME")) + DIR_DELIM + "." + lowercase(PROJECT_NAME); #endif #endif // RUN_IN_PLACE }
/** * @brief Actually determine whether the string represented by this * particular type instance has a terminating NULL-character. * @note If asciiStringGuaranteedNullTerminated() is false, then this method * actually scans the string for a NULL-terminator. * @warning supportsAsciiStringInterface() must be true and isNull() must be * false for this method to be usable. * * @return Whether the underlying string is has a NULL-terminator. **/ virtual bool asciiStringNullTerminated() const { FATAL_ERROR("Used an AsciiString interface method on a non-AsciiString TypeInstance."); }
/* Set ARCHIVE for writing, then compressing an archive. */ void sys_child_open_for_compress (void) { FATAL_ERROR ((0, 0, _("Cannot use compressed or remote archives"))); }