bool StreamerSDL::saveBitmap(const Bitmap & bitmap, std::ostream & output) { if(bitmap.getPixelFormat() == PixelFormat::MONO_FLOAT) { Reference<Bitmap> tmp = BitmapUtils::convertBitmap(bitmap, PixelFormat::MONO); return saveBitmap(*tmp.get(), output); } SDL_Surface * surface = BitmapUtils::createSDLSurfaceFromBitmap(bitmap); if (surface == nullptr) { return false; } // Save the bitmap to a file temporarily. static TemporaryDirectory tempDir("StreamerSDL"); FileName fileName(tempDir.getPath()); do { fileName.setFile(StringUtils::createRandomString(16) + ".bmp"); } while(FileUtils::isFile(fileName)); int success = SDL_SaveBMP(surface, fileName.getPath().c_str()); SDL_FreeSurface(surface); if(success != 0) { FileUtils::remove(fileName); return false; } std::ifstream fileInput(fileName.getPath().c_str(), std::ios_base::binary); output << fileInput.rdbuf(); fileInput.close(); FileUtils::remove(fileName); return true; }
//Read in info from text file, add them to vector void loadHeroes(string filename, vector<Hero*> &heroes) { heroes.clear(); string line = ""; std::ifstream fileInput(filename); while (getline(fileInput, line)) { heroes.push_back(new Hero(line)); } }
string SGFileBefore::readStringFromFile(const char* fileName) { ifstream fileInput(fileName); if (!fileInput.good()) { printf("File failed to load...\"%s\"\n", fileName); //while (1); } string returnTarget = string(istreambuf_iterator<char>(fileInput), istreambuf_iterator<char>()); return returnTarget; }
int main(int argc, char *argv[]) { char board[41][41] = {{'\0', '\0'}}; char tempBoard[41][41] = {{'\0', '\0'}}; if(argc == 1) { // if no other file in command line blankBoard(board, tempBoard); printBoard(board); while(userInput(board, tempBoard)); } else { // if file in command line fileInput(argv[1], board, tempBoard); } return 0; }
string genFileSHA1AndLen( const string &filePath, uint64_t *fileLen = NULL) { static char hexBytes[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}; unsigned char sha1[SHA_DIGEST_LENGTH]; ifstream fileInput(filePath.c_str(), ios::in | ios::binary); if (!fileInput) { return ""; } if (fileLen != NULL) { fileInput.seekg(0 , std::ios::end); *fileLen = fileInput.tellg(); fileInput.seekg(0 , std::ios::beg); } const int sliceSize = 2*1024*1024; char buf[sliceSize]; SHA_CTX ctx; SHA1_Init(&ctx); uint64_t len = 0; while(!fileInput.eof()) { fileInput.read(buf, sliceSize); len = fileInput.gcount(); SHA1_Update( &ctx, buf, len); } SHA1_Final(sha1, &ctx); fileInput.close(); string shaStr = ""; for (int i=0; i<SHA_DIGEST_LENGTH; i++) { shaStr += hexBytes[sha1[i] >> 4]; shaStr += hexBytes[sha1[i] & 0x0f]; } return shaStr; }
void SGFileBefore::readMeshFile( const char* fileName, SGDagNodeContainer& container ) { ifstream fileInput(fileName, ios::binary); if (!fileInput.good()) { printf("File failed to load...\"%s\"\n", fileName); return; } short sizeofInt = sizeof(int); short sizeofDouble = sizeof(double); int numDataMesh; fileInput.read((char*)&numDataMesh, sizeofInt); for (int i = 0; i < numDataMesh; i++ ) { SGDagNodeMesh* ptrDagNodeMesh = new SGDagNodeMesh; SGDagNodeMesh& meshData = *ptrDagNodeMesh; fileInput.read((char*)&meshData.m_numVertices, sizeofInt); fileInput.read((char*)&meshData.m_numPolygons, sizeofInt); fileInput.read((char*)&meshData.m_numIdArrayVertices, sizeofInt); fileInput.read((char*)&meshData.m_numUVs, sizeofInt); meshData.m_uvArrays = new vector<vector2d>[meshData.m_numUVs]; for (int i = 0; i < meshData.m_numUVs; i++) meshData.m_uvArrays[i].resize(0); meshData.m_points.resize(meshData.m_numVertices); meshData.m_countArrayVertices.resize(meshData.m_numPolygons); meshData.m_idArrayVertices.resize(meshData.m_numIdArrayVertices); fileInput.read((char*)&meshData.m_matrix[0], sizeofDouble *16 ); fileInput.read((char*)&meshData.m_points[0], sizeofDouble*meshData.m_numVertices * 3); fileInput.read((char*)&meshData.m_countArrayVertices[0], sizeofInt*meshData.m_numPolygons); fileInput.read((char*)&meshData.m_idArrayVertices[0], sizeofInt*meshData.m_numIdArrayVertices); meshData.updateBoundingBox(); meshData.setDatasComopnentRelationship(); meshData.setVertexNormals(); meshData.setBuffer(); container.append(ptrDagNodeMesh); } fileInput.close(); }
bool read_text_archive( const std::string& file_name, T& data_structure){ int fileDescriptor = open(file_name.c_str(), O_RDONLY); if( fileDescriptor < 0 ) { LOG(INFO) << " Error opening the file "<< file_name; return false; } google::protobuf::io::FileInputStream fileInput(fileDescriptor); fileInput.SetCloseOnDelete( true ); if(google::protobuf::TextFormat::Parse(&fileInput, &data_structure)) { return true; }else{ LOG(INFO) << "Failed to parse file: " << file_name; return false; } }
int main(int argc, const char * argv[]) { bool startRepl = false; if (argc == 1) { startRepl = true; } // execute any files passed on the command line int argpos = 1; while (argpos < argc) { std::string filename(argv[argpos]); if (filename=="-h") { std::cout << "help: -h prints this message, -r starts the repl, pass any files to execute" << std::endl; startRepl = false; } else if (filename=="-r") { // guarantee that the repl starts startRepl = true; } std::ifstream t(filename); std::string fileInput((std::istreambuf_iterator<char>(t)),std::istreambuf_iterator<char>()); try { tinyclojure::TinyClojure interpreter; std::vector<tinyclojure::Object*> expressions; interpreter.parseAll(fileInput, expressions); for (int expressionIndex = 0; expressionIndex < expressions.size(); ++expressionIndex) { interpreter.eval(expressions[expressionIndex])->stringRepresentation(); } } catch (tinyclojure::Error error) { std::cout << error.position << ": " << error.message << std::endl << std::endl; } ++argpos; } if (startRepl) { repl(); } return 0; }
int main_FileCopy () { std::ifstream fileInput("RepeatArray.cpp",std::ios::binary); std::ofstream fileOutput("testing.txt",std::ios::binary); char line[10]={}; int filesize; struct stat results; if (stat("RepeatArray.cpp", &results) == 0) { filesize= results.st_size; } else { printf("Error\n"); } printf("size of file %d\n",filesize); const int chunk=10; int size = filesize; while(size>chunk) { fileInput.read(line,chunk); fileOutput.write(line,chunk) ; size =size-chunk; } fileInput.read(line,size); fileOutput.write(line,size); fileInput.close(); fileOutput.close(); return 0; }
int main() { // faili lugemine FILE *inputFile = fopen(I_FILENAME, "r"); if (inputFile == NULL) { printf("Faili avamine ebaõnnestus\n"); return 0; } int lines = countlines(inputFile) - 1; // loeme read üle, selleks et teada massiivi suurust if (DEBUG) printf("Ridade arv: %d\n", lines); Isik vanemad[lines]; // loeme sisendfailist Isik llvanemad[lines]; // lastelastega vanemad rewind(inputFile); // resetib faili pointer tagasi algusesse. Alternatiiv oleks fail uuesti avada. fileInput(inputFile, vanemad); fclose(inputFile); // väljastame testimiseks if (DEBUG) { printf("\nLapsed:\n"); printEntries(vanemad, lines); } // leiame lapselapsed findGrandChildren(vanemad, llvanemad, lines); // väljastame testimiseks if (DEBUG) { printf("\n=====================\n"); printf("\nLapselapsed:\n"); printEntries(llvanemad, lines); } // TODO: faili kirjutamine return 0; }
int main() { int fLines, start =2, i; char *fName = "worldcitiespoppartial.txt"; float **fpArray; int childpid, fds[2]; fpArray = fileInput(fName, &fLines); printf("Before it forks\n"); pipe(fds); childpid = fork(); if (childpid==0){ printf("This is a child Process\n"); fpArray = iSort(fpArray, (fLines/2), start); write(fds[1], fpArray, sizeof(long int)*3*fLines/2 ); } else { printf("This is a parent Process\n"); wait(NULL); read(fds[0], fpArray, sizeof(long int)*3*fLines/2); fpArray = iSort(fpArray, (fLines), (fLines/2)); fpArray = mSort(fpArray, fLines); for(i=1;i<fLines; i++){ printf("%.f %f %f\n", fpArray[i][0], fpArray[i][1], fpArray[i][2]); } } return(0); }
void LevelManager::loadGame(){ ifstream fileInput(FILENAME); string input; while (!fileInput.eof()){ fileInput >> input; if (input == LEVEL){ fileInput >> input; loadedLevel = stoi(input); if (loadedLevel > mLevelProgression){ mLevelProgression = loadedLevel; } } if (input == COLLECT){ fileInput >> input; loadedCollectibles = stoi(input); if (loadedCollectibles > mLevelProgression){ mCollectibles = loadedCollectibles; } }
void LoggingWindow::on_loadBackupButton_clicked() { QString path = QDir::currentPath(); if (backupFolder != "") { path = backupFolder; } QString fileToOpen = QFileDialog::getOpenFileName(this, "Open Backup", path, tr("Backup File (*.backup)")); if (fileToOpen != "") { QFile backupFile(fileToOpen); QTextStream fileInput(&backupFile); if (backupFile.open(QIODevice::ReadOnly | QIODevice::Text)) { while (!fileInput.atEnd()) { qDebug() << "Loading line of Backup File"; QString line = fileInput.readLine(); data[dataPointer] = new DataPoint(this); data[dataPointer]->addBackupData(line); emit updateGraphs(data[dataPointer]); this->addToTable(data[dataPointer]->className(), data[dataPointer]->airQuality(), data[dataPointer]->deltaAirQuality(), data[dataPointer]->year(), data[dataPointer]->boys(), data[dataPointer]->girls(), data[dataPointer]->timeOfLog()); lastValue = data[dataPointer]->airQuality(); dataPointer++; } } } }
//********************************************************************************* // Start of main function // parameters: // * filename - name of the input-file //********************************************************************************* void BuildRAAStudents(TString filename = "RAABaseOutput.root"){ //________Reset ROOT_______________________________________________________________ gROOT->Reset(); //________Set basic style setting__________________________________________________ StyleSettings(); cout << "Analysing file " << filename.Data() << endl; //********************************************************************************* //Definition of number of Collisions in the different centrality classes //********************************************************************************* Double_t nColl_0_5 =1686.87; Double_t nColl_0_10 = 1502.7; Double_t nColl_5_10 = 1319.89; Double_t nColl_10_20 = 923.26; Double_t nColl_20_30 = 558.68; Double_t nColl_30_40 = 321.20; Double_t nColl_40_50 = 171.67; Double_t nColl_50_60 = 85.13; Double_t nColl_60_70 = 38.51; Double_t nColl_70_80 = 15.78; Double_t nColl_80_90 = 6.32; //********************************************************************************* //Attaching & reading the input-file //********************************************************************************* TFile fileInput(filename.Data()); //____ reading the number of TPC tracks for pp events & 0-5% PbPb events___________ TH1D *hNTracksTPCPbPb_0_5 = (TH1D*)fileInput.Get(Form("nTracksTPC_PbPb_%i-%i",0,5)); TH1D *hNTracksTPCPbPb_70_80 = (TH1D*)fileInput.Get(Form("nTracksTPC_PbPb_%i-%i",70,80)); /// To do: Do the same for the other centralities //_____reading the pt-spectrum for 0-5% & 70-80% PbPb events, scaling it___________ //_____by corresponding number of Collisions (nColl)_______________________________ TH1D *hTrackPtPbPb_0_5 = (TH1D*)fileInput.Get(Form("trackPt_PbPb_%i-%i",0,5)); hTrackPtPbPb_0_5->Scale(1./nColl_0_5); TH1D *hTrackPtPbPb_70_80 = (TH1D*)fileInput.Get(Form("trackPt_PbPb_%i-%i",70,80)); hTrackPtPbPb_70_80->Scale(1./nColl_70_80); /// To do: Do the same for the other centralities //********************************************************************************* // Attaching and Reading pp-reference file //********************************************************************************* TFile *fileInputPP = new TFile("PP_2760GeV_BaseLine.root"); TH1F *hNTracksTPCpp = (TH1F*)fileInputPP->Get("nTracksTPC_pp"); TH1D *hTrackPtpp = (TH1D*)fileInputPP->Get("trackPt_pp"); //********************************************************************************* // Building the RCP //********************************************************************************* TH1D* hRCP_0_5 = (TH1D*)hTrackPtPbPb_0_5->Clone("RCP_vs_Pt_0-5"); hRCP_0_5->Sumw2(); hRCP_0_5->Divide(hTrackPtPbPb_70_80); /// To do: Do the same for the other centralities //********************************************************************************* // Building the RAA //********************************************************************************* /// To Do: Here you need to add the histograms for RAA (PbPb-pt-spectrum in a certain centrality, scaled by NColl, devided by the pp reference spectrum //********************************************************************************* //Definition of canvas //********************************************************************************* TCanvas *c1 = new TCanvas("c1","Pt"); TCanvas *c2 = new TCanvas("c2","nTracksTPC"); TCanvas *c3 = new TCanvas("c3","RCP"); TCanvas *c4 = new TCanvas("c4","RAA"); //********************************************************************************* // * Plotting the track pt for 0-5, 70-80 PbPb events and pp events //********************************************************************************* c1->cd(); c1->SetLogy(1); hTrackPtpp->GetYaxis()->SetTitleOffset(1.3); HistoSetMarkerAndColor( hTrackPtpp, 20,0.8, kRed, kRed); hTrackPtpp->Draw("e1"); HistoSetMarkerAndColor( hTrackPtPbPb_0_5, 20,0.8, kBlue+2, kBlue+2); hTrackPtPbPb_0_5->Draw("same,e1"); HistoSetMarkerAndColor( hTrackPtPbPb_70_80, 20,0.8, kMagenta+2, kMagenta+2); hTrackPtPbPb_70_80->Draw("same,e1"); /// To do: Add different centralities to this plot and the legend TLegend* legendTrackPt = new TLegend(0.55,0.70,0.95,0.9); legendTrackPt->SetTextSize(0.03); legendTrackPt->SetFillColor(0); legendTrackPt->SetLineColor(0); legendTrackPt->SetNColumns(2); legendTrackPt->AddEntry(hTrackPtPbPb_0_5,"PbPb 0-5 %"); legendTrackPt->AddEntry(hTrackPtPbPb_70_80,"PbPb 70-80 %"); legendTrackPt->AddEntry(hTrackPtpp,"pp"); legendTrackPt->Draw(); c1->SaveAs("trackPt_compared.eps"); //********************************************************************************* // * Plotting of the multiplicity histogram for 0-5%, 70-80% PbPb & pp //********************************************************************************* c2->cd(); c2->SetLogy(1); hNTracksTPCpp->GetYaxis()->SetRangeUser(5.e-6,1.); hNTracksTPCpp->GetYaxis()->SetTitleOffset(1.3); HistoSetMarkerAndColor( hNTracksTPCpp, 20,0.8, kRed, kRed); hNTracksTPCpp->Draw("e1"); HistoSetMarkerAndColor( hNTracksTPCPbPb_0_5, 20,0.8, kBlue+2, kBlue+2); hNTracksTPCPbPb_0_5->Draw("same,e1"); HistoSetMarkerAndColor( hNTracksTPCPbPb_70_80, 20,0.8, kMagenta+2, kMagenta+2); hNTracksTPCPbPb_70_80->Draw("same,e1"); /// To do: Add different centralities to this plot and the legend legendTrackPt->Draw(); c2->Update(); c2->SaveAs("nTracksTPC_compared.eps"); //********************************************************************************** // Axis labeling & plotting of the RCP for 0-5% //********************************************************************************** c3->cd(); c3->SetLogy(0); hRCP_0_5->SetTitle("R_{CP} for different centralities"); hRCP_0_5->SetXTitle("p_{t} (GeV/c)"); hRCP_0_5->SetYTitle("R_{CP} = #frac{1/N^{AA,X}_{evt} 1/<N_{coll,X}> dN^{AA,X}/dp_{t}}{1/N^{PbPb,per}_{evt} 1/<N_{coll,per}> dN^{PbPb,per}/dp_{t}}"); hRCP_0_5->GetYaxis()->SetTitleOffset(1.3); hRCP_0_5->GetYaxis()->SetRangeUser(0.,1.5); HistoSetMarkerAndColor( hRCP_0_5, 20,0.8, kBlue+2, kBlue+2); hRCP_0_5->Draw("e1"); /// To do: Add different centralities to this plot and the legend TLegend* legendRCP = new TLegend(0.15,0.78,0.55,0.9); legendRCP->SetTextSize(0.03); legendRCP->SetFillColor(0); legendRCP->SetLineColor(0); legendRCP->SetNColumns(4); legendRCP->AddEntry(hRCP_0_5,"0-5 %"); legendRCP->Draw(); c3->Update(); c3->SaveAs("RCP_compared.eps"); //********************************************************************************** // Axis labeling & plotting of the RAA in the different classes //********************************************************************************** /// To do: Plot RAA in the different centrality classes, use RCP plot as an example }
int main() { std::ifstream fileInput("testData.txt"); std::size_t numLines = 0; std::string line; while ( std::getline(fileInput,line) ) { numLines++; } fileInput.clear(); fileInput.seekg(0,fileInput.beg); std::vector<std::vector<double> > dataVec(numLines, std::vector<double> (8, 0)); int lineNum = 0; double startingTime; while( std::getline(fileInput, line)) { std::istringstream iss(line); for (int i = 0; i < 8; i++) { iss >> dataVec[lineNum][i]; } if ( lineNum == 0 ) { startingTime = dataVec[0][0]; } dataVec[lineNum][0] -= startingTime; lineNum++; } double diff = (dataVec[numLines-1][0] - dataVec[0][0])/(numLines); typedef std::chrono::high_resolution_clock Clock; typedef std::chrono::duration<double> secDouble; std::chrono::high_resolution_clock timer; Clock::time_point startTime = timer.now(); secDouble secs; int timeIndex = 0; int prevValue = 0; std::vector<double> angles; angles.resize(6); while( true ) { secs = timer.now() - startTime; timeIndex = std::round( secs.count() / diff ); if (timeIndex != prevValue) { angles.assign(dataVec[timeIndex].begin() + 1, dataVec[timeIndex].end() - 1); std::cout << '\r'; for ( int i = 0; i < 6; i++) { std::cout << angles[i] << ", "; } std::cout << std::flush; prevValue = timeIndex; } } return 0; }
l1menu::ReducedSamplePrivateMembers::ReducedSamplePrivateMembers( const l1menu::ReducedSample& thisObject, const std::string& filename ) : event(thisObject), triggerMenu(mutableTriggerMenu_), eventRate(1), sumOfWeights(0) { GOOGLE_PROTOBUF_VERIFY_VERSION; // Open the file with read ability int fileDescriptor = open( filename.c_str(), O_RDONLY ); if( fileDescriptor==0 ) throw std::runtime_error( "ReducedSample initialise from file - couldn't open file" ); ::UnixFileSentry fileSentry( fileDescriptor ); // Use this as an exception safe way of closing the input file google::protobuf::io::FileInputStream fileInput( fileDescriptor ); // First read the magic number at the start of the file and make sure it // matches what I expect. This is uncompressed so I'll wrap it in a block // to make sure the CodedInputStream is destructed before creating a new // one with gzip input. { google::protobuf::io::CodedInputStream codedInput( &fileInput ); // As a read buffer, I'll create a string the correct size (filled with an arbitrary // character) and read straight into that. std::string readMagicNumber; if( !codedInput.ReadString( &readMagicNumber, FILE_FORMAT_MAGIC_NUMBER.size() ) ) throw std::runtime_error( "ReducedSample initialise from file - error reading magic number" ); if( readMagicNumber!=FILE_FORMAT_MAGIC_NUMBER ) throw std::runtime_error( "ReducedSample - tried to initialise with a file that is not the correct format" ); google::protobuf::uint32 fileformatVersion; if( !codedInput.ReadVarint32( &fileformatVersion ) ) throw std::runtime_error( "ReducedSample initialise from file - error reading file format version" ); // So far I only have (and ever expect to have) one version of the file // format, imaginatively versioned "1". You never know though... if( fileformatVersion>1 ) std::cerr << "Warning: Attempting to read a ReducedSample with version " << fileformatVersion << " with code that only knows up to version 1." << std::endl; } google::protobuf::io::GzipInputStream gzipInput( &fileInput ); google::protobuf::io::CodedInputStream codedInput( &gzipInput ); // Disable warnings on this input stream (second parameter, -1). The // first parameter is the default. I'll change this if necessary in // the loop later. size_t totalBytesLimit=67108864; codedInput.SetTotalBytesLimit( totalBytesLimit, -1 ); google::protobuf::uint64 messageSize; // Read the size of the header message if( !codedInput.ReadVarint64( &messageSize ) ) throw std::runtime_error( "ReducedSample initialise from file - error reading message size for header" ); google::protobuf::io::CodedInputStream::Limit readLimit=codedInput.PushLimit(messageSize); if( !protobufSampleHeader.ParseFromCodedStream( &codedInput ) ) throw std::runtime_error( "ReducedSample initialise from file - some unknown error while reading header" ); codedInput.PopLimit(readLimit); // Keep looping until there is nothing more to be read from the file. while( codedInput.ReadVarint64( &messageSize ) ) { readLimit=codedInput.PushLimit(messageSize); // Make sure the CodedInputStream doesn't refuse to read the message because it's // read too much already. I'll also add an arbitrary 50 on to always make sure // I can read the next messageSize if there is one. if( gzipInput.ByteCount()+messageSize+50 > totalBytesLimit ) { totalBytesLimit+=messageSize*5; // Might as well set it a little higher than necessary while I'm at it. codedInput.SetTotalBytesLimit( totalBytesLimit, -1 ); } std::unique_ptr<l1menuprotobuf::Run> pNewRun( new l1menuprotobuf::Run ); if( !pNewRun->ParseFromCodedStream( &codedInput ) ) throw std::runtime_error( "ReducedSample initialise from file - some unknown error while reading run" ); protobufRuns.push_back( std::move( pNewRun ) ); codedInput.PopLimit(readLimit); } // Always make sure there is at least one Run ready to be added to. Later // code assumes there is already a run there. if( protobufRuns.empty() ) { std::unique_ptr<l1menuprotobuf::Run> pNewRun( new l1menuprotobuf::Run ); protobufRuns.push_back( std::move( pNewRun ) ); } // Count up the sum of the weights of all events for( const auto& pRun : protobufRuns ) { sumOfWeights+=sumWeights( *pRun ); } // I have all of the information in the protobuf members, but I also need the trigger information // in the form of l1menu::TriggerMenu. Copy out the required information. for( int triggerNumber=0; triggerNumber<protobufSampleHeader.trigger_size(); ++triggerNumber ) { const l1menuprotobuf::Trigger& inputTrigger=protobufSampleHeader.trigger(triggerNumber); mutableTriggerMenu_.addTrigger( inputTrigger.name(), inputTrigger.version() ); // Get a reference to the trigger I just created l1menu::ITrigger& trigger=mutableTriggerMenu_.getTrigger(triggerNumber); // Run through all of the parameters and set them to what they were // when the sample was made. for( int parameterNumber=0; parameterNumber<inputTrigger.parameter_size(); ++parameterNumber ) { const auto& inputParameter=inputTrigger.parameter(parameterNumber); trigger.parameter(inputParameter.name())=inputParameter.value(); } // I should probably check the threshold names exist. I'll do it another time. } }
int Video::upload_data( const uint64_t fileSize, const string &sha, const uint64_t sliceSize, const string &sign, const string &url, const string &srcPath, const uint64_t offset, const string &session ) { int ret = 0; char tmp_buf[1024]; char buf[sliceSize]; vector<string> headers; headers.push_back("Authorization: " + sign); ifstream fileInput(srcPath.c_str(), ios::in | ios::binary); fileInput.seekg(offset); uint64_t pos = offset; while (fileSize > pos) { reset(); uint64_t len =0; fileInput.read(buf, sliceSize); len = fileInput.gcount(); struct curl_httppost *firstitem = NULL, *lastitem = NULL; ret = curl_formadd(&firstitem, &lastitem, CURLFORM_COPYNAME, "op", CURLFORM_COPYCONTENTS, "upload_slice", CURLFORM_END); snprintf(tmp_buf, sizeof(tmp_buf), "%lu", pos); ret = curl_formadd(&firstitem, &lastitem, CURLFORM_COPYNAME, "offset", CURLFORM_COPYCONTENTS, tmp_buf, CURLFORM_END); ret = curl_formadd(&firstitem, &lastitem, CURLFORM_COPYNAME, "session", CURLFORM_COPYCONTENTS, session.c_str(), CURLFORM_END); ret = curl_formadd(&firstitem, &lastitem, CURLFORM_COPYNAME, "filecontent", CURLFORM_BUFFER, "data", CURLFORM_BUFFERPTR, buf, CURLFORM_BUFFERLENGTH, len, CURLFORM_END); int retry_times = 0; do { sendRequest( url, 1, &headers, NULL, firstitem); dump_res(); if (retCode == 0) { break; } retry_times++; } while(retry_times < MAX_RETRY_TIMES); curl_formfree(firstitem); if (retCode != 0) { return retCode; } pos += sliceSize; } return retCode; }