int birom16_new(struct birom16_state **state, struct chipdef16 *chip, struct serial *serial) { char path[256]; int rc; assert(state); *state = calloc(1, sizeof(struct birom16_state)); assert(*state); (*state)->chip = chip; (*state)->serial = serial; LOGD("User says MCU is '%s' on '%s'.", chip->name, serial->address); memset(path, 0x00, sizeof(path)); snprintf(path, sizeof(path) - 1, "kernal16/%s", chip->kernal); (*state)->kernalsize = filedata(path, &(*state)->kernaldata); if ((*state)->kernalsize <= 0 || (*state)->kernaldata == NULL) { LOGE("Could not read contents of '%s'.", path); return E_READ; } LOGD("Loaded '%s' (0x%02X bytes).", path, (*state)->kernalsize); return E_NONE; }
static int process_new(struct sbuf *p1b, FILE *ucfp, const char *currentdata, const char *datadirtmp, const char *deltmppath, struct dpth *dpth, int *resume_partial, struct cntr *cntr, struct config *cconf) { if(*resume_partial && p1b->cmd==CMD_FILE && cconf->librsync && p1b->compression==cconf->compression) { if(resume_partial_new_file(p1b, cntr, currentdata, datadirtmp, deltmppath, dpth, cconf)) return -1; // Burp only transfers one file at a time, so // if there was an interruption, there is only // a possibility of one partial file to resume. *resume_partial=0; } if(filedata(p1b->cmd)) { //logp("need to process new file: %s\n", p1b->path); // Flag the things that need to be sent (to the client) p1b->sendstat++; p1b->sendpath++; } else { new_non_file(p1b, ucfp, p1b->cmd, cntr); } return 0; }
bool FileHelper::ReadAllText(const String & fileName, String & content) { Handle hFile = CreateFileW(StringUtils::Utf8ToUtf16(fileName).c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, 0, nullptr); if(hFile == INVALID_HANDLE_VALUE) return false; unsigned int filesize = GetFileSize(hFile, 0); if(!filesize) { content.clear(); return true; } Memory<char*> filedata(filesize + 1, "FileReader::ReadAllText:filedata"); DWORD read = 0; if(!ReadFile(hFile, filedata(), filesize, &read, 0)) return false; content = String(filedata()); return true; }
int main(int argc, char* argv[]){ if(argc != 2){ fprintf(stderr, "Usage: [filename]\n"); exit(1); } filedata(argv[1]); return 0; }
std::vector<uint8_t> RARCFile::corrupt() { // Commented section corrupts individual files passed on the command line // which won't be used until the GUI has a better design /* for (auto& path : info->files()) { if (entries.count(path) == 0) { // File doesn't exist as it was given, print error and go to next iteration debug::cerr << "Entry doesn't exist: " << path << std::endl; continue; } detail::FileEntry entry = entries.at(path); uint32_t offset = header->start() + entry.offset(); std::vector<uint8_t> filedata(data.begin() + offset, data.begin() + offset + entry.size()); std::ofstream ofs(entry.name(), std::ios::binary); ofs.write(reinterpret_cast<char *>(&filedata[0]), entry.size()); ofs.close(); // Since RARC files are archives of Nintendo files, corrupt it with Nintendo file protection NintendoFile::start(filedata, arguments); std::copy(filedata.begin(), filedata.begin() + entry.size(), data.begin() + offset); } */ for (auto& e : entries) { detail::FileEntry entry = e.second; uint32_t offset = header->start() + entry.offset(); if (data.size() < offset + entry.size()) { continue; } std::vector<uint8_t> filedata(data.begin() + offset, data.begin() + offset + entry.size()); // If the file is Yay0 or Yaz0 compressed then ignore it since the sizes most likely won't match if (filedata.size() > 4 && util::read(filedata, 0, 4) != "Yaz0" && util::read(filedata, 0, 4) != "Yay0") { // Since RARC files are archives of Nintendo files, corrupt it with Nintendo file protection NintendoFile::start(filedata, arguments); // Copy the corrupted bytes back into place // NOTE: This does not account for differing sizes for Yaz0 compressed files! std::copy(filedata.begin(), filedata.begin() + entry.size(), data.begin() + offset); } } return data; }
int main(int argc, char* argv[]) { if( argc != 2){ std::cout<< "Usage: "<<argv[0]<<" <path to file>" << std::endl; return 1; } std::string outputstr = ""; std::ostringstream oss; //change this to actually read a file from disk instead of stdin mpz_class filedata(argv[1]); //if compiler supported c++11 we could use this to search for filedata in TWOS[], but I'm on debian stable w gcc 4.6 :/ //bool exists = std::find(std::begin(TWOS), std::end(TWOS), filedata) != std::end(TWOS); int exponent = powerOfTwo(filedata); mpz_class remainder( filedata - TWOS[exponent]); if( remainder == 0 ){ oss << exponent; outputstr = "2^" + oss.str(); std::cout << outputstr << std::endl; return 0; } std::cout << "exponent is " << exponent << std::endl; std::cout << "twos[exponent] is " << TWOS[exponent] << std::endl; std::cout << TWOS[exponent] << std:: endl; std::cout << filedata << std::endl; std::cout << "iterating on remainder which equals" << remainder << std::endl; while(remainder >= 128){ //can't just concatenate an int to a string oss << exponent; outputstr+="2^" +oss.str()+ "+"; //see if the remainder is near any powers of two exponent = powerOfTwo(remainder); remainder = remainder - TWOS[exponent]; std::cout << exponent << std::endl; //set stringstream to empty string and then clear error flag(s) oss.str(""); oss.clear(); } oss.str(""); oss.clear(); oss << remainder; outputstr += oss.str(); std::cout << outputstr << std::endl; return 0; }
std::vector<std::string> OpenFileDialog(const char * filter) { char curDir[MAX_PATH]; GetCurrentDirectoryA(MAX_PATH,curDir); std::vector<char> filedata(MAX_PATH * 1000); char * szFileName = &filedata[0]; OPENFILENAMEA opf; opf.hwndOwner = 0; opf.lpstrFilter = filter; opf.lpstrCustomFilter = 0; opf.nMaxCustFilter = 0L; opf.nFilterIndex = 1L; opf.lpstrFile = szFileName; opf.nMaxFile = (DWORD)filedata.size(); opf.lpstrFileTitle = 0; opf.nMaxFileTitle=50; opf.lpstrInitialDir = 0; opf.lpstrTitle = "Open"; opf.nFileOffset = 0; opf.nFileExtension = 2; opf.lpstrDefExt = "*.*"; opf.lpfnHook = NULL; opf.lCustData = 0; opf.Flags = OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT | OFN_ALLOWMULTISELECT | OFN_EXPLORER; //opf.Flags = OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT; opf.lStructSize = sizeof(OPENFILENAMEA); std::vector<std::string> retval; if(GetOpenFileNameA(&opf)) { if(opf.nFileOffset > strlen(szFileName)) { std::string path = std::string(szFileName) + "\\"; unsigned startOffset = opf.nFileOffset; while(szFileName[startOffset]) { retval.push_back( path + std::string(&szFileName[startOffset])); startOffset += (unsigned int) strlen(&szFileName[startOffset])+1; } } else retval.push_back(szFileName); } else { DWORD retval = CommDlgExtendedError(); while(0); } SetCurrentDirectoryA(curDir); return retval; }
static int process_new(struct sdirs *sdirs, struct conf *cconf, struct sbuf *p1b, FILE *ucfp, struct dpthl *dpthl) { if(!p1b->path.buf) return 0; if(filedata(p1b->path.cmd)) { //logp("need to process new file: %s\n", p1b->path); // Flag the things that need to be sent (to the client) p1b->flags |= SBUFL_SEND_STAT; p1b->flags |= SBUFL_SEND_PATH; } else { new_non_file(p1b, ucfp, cconf); } return 0; }
void ReadFile(RobotBasePtr& probot, const std::string& filename, const AttributesList& atts) { std::ifstream f(filename.c_str()); if( !f ) { throw OPENRAVE_EXCEPTION_FORMAT("failed to read %s filename",filename,ORE_InvalidArguments); } f.seekg(0,ios::end); std::vector<char> filedata(static_cast<size_t>(f.tellg())+1, 0); // need a null-terminator f.seekg(0,ios::beg); f.read(&filedata[0], filedata.size()); Read(probot,filedata,atts); probot->__struri = filename; #if defined(HAVE_BOOST_FILESYSTEM) && BOOST_VERSION >= 103600 // stem() was introduced in 1.36 boost::filesystem::path bfpath(filename); #if defined(BOOST_FILESYSTEM_VERSION) && BOOST_FILESYSTEM_VERSION >= 3 probot->SetName(utils::ConvertToOpenRAVEName(bfpath.stem().string())); #else probot->SetName(utils::ConvertToOpenRAVEName(bfpath.stem())); #endif #endif }
static bool scriptcreatelinemap(const char* filename) { Handle hFile = CreateFileW(StringUtils::Utf8ToUtf16(filename).c_str(), GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0); if(hFile == INVALID_HANDLE_VALUE) { GuiScriptError(0, "CreateFile failed..."); return false; } unsigned int filesize = GetFileSize(hFile, 0); if(!filesize) { GuiScriptError(0, "Empty script..."); return false; } Memory<char*> filedata(filesize + 1, "createlinemap:filedata"); DWORD read = 0; if(!ReadFile(hFile, filedata(), filesize, &read, 0)) { GuiScriptError(0, "ReadFile failed..."); return false; } hFile.Close(); int len = (int)strlen(filedata()); char temp[256] = ""; LINEMAPENTRY entry; memset(&entry, 0, sizeof(entry)); std::vector<LINEMAPENTRY>().swap(linemap); for(int i = 0, j = 0; i < len; i++) //make raw line map { if(filedata()[i] == '\r' && filedata()[i + 1] == '\n') //windows file { memset(&entry, 0, sizeof(entry)); int add = 0; while(temp[add] == ' ') add++; strcpy_s(entry.raw, temp + add); *temp = 0; j = 0; i++; linemap.push_back(entry); } else if(filedata()[i] == '\n') //other file { memset(&entry, 0, sizeof(entry)); int add = 0; while(temp[add] == ' ') add++; strcpy_s(entry.raw, temp + add); *temp = 0; j = 0; linemap.push_back(entry); } else if(j >= 254) { memset(&entry, 0, sizeof(entry)); int add = 0; while(temp[add] == ' ') add++; strcpy_s(entry.raw, temp + add); *temp = 0; j = 0; linemap.push_back(entry); } else j += sprintf(temp + j, "%c", filedata()[i]); } if(*temp) { memset(&entry, 0, sizeof(entry)); strcpy_s(entry.raw, temp); linemap.push_back(entry); } int linemapsize = (int)linemap.size(); while(!*linemap.at(linemapsize - 1).raw) //remove empty lines from the end { linemapsize--; linemap.pop_back(); } for(int i = 0; i < linemapsize; i++) { LINEMAPENTRY cur = linemap.at(i); //temp. remove comments from the raw line char line_comment[256] = ""; char* comment = strstr(&cur.raw[0], "//"); if(comment && comment != cur.raw) //only when the line doesnt start with a comment { if(*(comment - 1) == ' ') //space before comment { strcpy_s(line_comment, comment); *(comment - 1) = '\0'; } else //no space before comment { strcpy_s(line_comment, comment); *comment = 0; } } int rawlen = (int)strlen(cur.raw); if(!rawlen) //empty { cur.type = lineempty; } else if(!strncmp(cur.raw, "//", 2)) //comment { cur.type = linecomment; strcpy_s(cur.u.comment, cur.raw); } else if(cur.raw[rawlen - 1] == ':') //label { cur.type = linelabel; sprintf(cur.u.label, "l %.*s", rawlen - 1, cur.raw); //create a fake command for formatting strcpy_s(cur.u.label, StringUtils::Trim(cur.u.label).c_str()); char temp[256] = ""; strcpy_s(temp, cur.u.label + 2); strcpy_s(cur.u.label, temp); //remove fake command if(!*cur.u.label || !strcmp(cur.u.label, "\"\"")) //no label text { char message[256] = ""; sprintf(message, "Empty label detected on line %d!", i + 1); GuiScriptError(0, message); std::vector<LINEMAPENTRY>().swap(linemap); return false; } int foundlabel = scriptlabelfind(cur.u.label); if(foundlabel) //label defined twice { char message[256] = ""; sprintf(message, "Duplicate label \"%s\" detected on lines %d and %d!", cur.u.label, foundlabel, i + 1); GuiScriptError(0, message); std::vector<LINEMAPENTRY>().swap(linemap); return false; } } else if(scriptgetbranchtype(cur.raw) != scriptnobranch) //branch { cur.type = linebranch; cur.u.branch.type = scriptgetbranchtype(cur.raw); char newraw[MAX_SCRIPT_LINE_SIZE] = ""; strcpy_s(newraw, StringUtils::Trim(cur.raw).c_str()); int len = (int)strlen(newraw); for(int i = 0; i < len; i++) if(newraw[i] == ' ') { strcpy_s(cur.u.branch.branchlabel, newraw + i + 1); break; } } else { cur.type = linecommand; strcpy_s(cur.u.command, cur.raw); } //append the comment to the raw line again if(*line_comment) sprintf(cur.raw + rawlen, " %s", line_comment); linemap.at(i) = cur; } linemapsize = (int)linemap.size(); for(int i = 0; i < linemapsize; i++) { auto & currentLine = linemap.at(i); if(currentLine.type == linebranch) //invalid branch label { int labelline = scriptlabelfind(currentLine.u.branch.branchlabel); if(!labelline) //invalid branch label { char message[256] = ""; sprintf(message, "Invalid branch label \"%s\" detected on line %d!", currentLine.u.branch.branchlabel, i + 1); GuiScriptError(0, message); std::vector<LINEMAPENTRY>().swap(linemap); return false; } else //set the branch destination line currentLine.u.branch.dest = scriptinternalstep(labelline); } } if(linemap.at(linemapsize - 1).type == linecomment || linemap.at(linemapsize - 1).type == linelabel) //label/comment on the end { memset(&entry, 0, sizeof(entry)); entry.type = linecommand; strcpy_s(entry.raw, "ret"); strcpy_s(entry.u.command, "ret"); linemap.push_back(entry); } return true; }
// return 1 to say that a file was processed static int maybe_process_file(struct sbuf *cb, struct sbuf *p1b, FILE *ucfp, const char *currentdata, const char *datadirtmp, const char *deltmppath, struct dpth *dpth, int *resume_partial, struct cntr *cntr, struct config *cconf) { int pcmp; // logp("in maybe_proc %s\n", p1b->path); if(!(pcmp=sbuf_pathcmp(cb, p1b))) { int oldcompressed=0; // If the file type changed, I think it is time to back it // up again (for example, EFS changing to normal file, or // back again). if(cb->cmd!=p1b->cmd) return process_new_file(cb, p1b, ucfp, currentdata, datadirtmp, deltmppath, dpth, resume_partial, cntr, cconf); // mtime is the actual file data. // ctime is the attributes or meta data. if(cb->statp.st_mtime==p1b->statp.st_mtime && cb->statp.st_ctime==p1b->statp.st_ctime) { // got an unchanged file //logp("got unchanged file: %s %c %c\n", cb->path, cb->cmd, p1b->cmd); return process_unchanged_file(cb, ucfp, cntr); } if(cb->statp.st_mtime==p1b->statp.st_mtime && cb->statp.st_ctime!=p1b->statp.st_ctime) { // File data stayed the same, but attributes or meta // data changed. We already have the attributes, but // may need to get extra meta data. if(cb->cmd==CMD_ENC_METADATA || p1b->cmd==CMD_ENC_METADATA // TODO: make unencrypted metadata use the librsync || cb->cmd==CMD_METADATA || p1b->cmd==CMD_METADATA || cb->cmd==CMD_VSS || p1b->cmd==CMD_VSS || cb->cmd==CMD_ENC_VSS || p1b->cmd==CMD_ENC_VSS || cb->cmd==CMD_VSS_T || p1b->cmd==CMD_VSS_T || cb->cmd==CMD_ENC_VSS_T || p1b->cmd==CMD_ENC_VSS_T || cb->cmd==CMD_EFS_FILE || p1b->cmd==CMD_EFS_FILE) return process_new_file(cb, p1b, ucfp, currentdata, datadirtmp, deltmppath, dpth, resume_partial, cntr, cconf); else return process_unchanged_file(cb, ucfp, cntr); } // Got a changed file. //logp("got changed file: %s\n", p1b->path); // If either old or new is encrypted, or librsync is off, // we need to get a new file. if(!cconf->librsync || cb->cmd==CMD_ENC_FILE || p1b->cmd==CMD_ENC_FILE || cb->cmd==CMD_ENC_METADATA || p1b->cmd==CMD_ENC_METADATA || cb->cmd==CMD_EFS_FILE || p1b->cmd==CMD_EFS_FILE // TODO: make unencrypted metadata use the librsync || cb->cmd==CMD_METADATA || p1b->cmd==CMD_METADATA || cb->cmd==CMD_VSS || p1b->cmd==CMD_VSS || cb->cmd==CMD_ENC_VSS || p1b->cmd==CMD_ENC_VSS || cb->cmd==CMD_VSS_T || p1b->cmd==CMD_VSS_T || cb->cmd==CMD_ENC_VSS_T || p1b->cmd==CMD_ENC_VSS_T) return process_new_file(cb, p1b, ucfp, currentdata, datadirtmp, deltmppath, dpth, resume_partial, cntr, cconf); // Get new files if they have switched between compression on // or off. if(cb->datapth && dpth_is_compressed(cb->compression, cb->datapth)) oldcompressed=1; if( ( oldcompressed && !cconf->compression) || (!oldcompressed && cconf->compression)) return process_new_file(cb, p1b, ucfp, currentdata, datadirtmp, deltmppath, dpth, resume_partial, cntr, cconf); // Otherwise, do the delta stuff (if possible). if(filedata(p1b->cmd)) { if(process_changed_file(cb, p1b, currentdata, datadirtmp, deltmppath, resume_partial, cntr, cconf)) return -1; } else { if(changed_non_file(p1b, ucfp, p1b->cmd, cntr)) return -1; } free_sbuf(cb); return 1; } else if(pcmp>0) { //logp("ahead: %s\n", p1b->path); // ahead - need to get the whole file if(process_new(p1b, ucfp, currentdata, datadirtmp, deltmppath, dpth, resume_partial, cntr, cconf)) return -1; // do not free return 1; } else { //logp("behind: %s\n", p1b->path); // behind - need to read more from the old // manifest // Count a deleted file - it was in the old manifest but not // the new. do_filecounter_deleted(cntr, cb->cmd); } return 0; }
// returns 1 for finished ok. static int do_stuff_to_receive(struct sbuf *rb, FILE *p2fp, const char *datadirtmp, struct dpth *dpth, const char *working, char **last_requested, const char *deltmppath, struct cntr *cntr, struct config *cconf) { int ret=0; char rcmd; size_t rlen=0; size_t wlen=0; char *rbuf=NULL; // This also attempts to write anything in the write buffer. if(async_rw(&rcmd, &rbuf, &rlen, '\0', NULL, &wlen)) { logp("error in async_rw\n"); return -1; } if(rbuf) { if(rcmd==CMD_WARNING) { logp("WARNING: %s\n", rbuf); do_filecounter(cntr, rcmd, 0); } else if(rb->fp || rb->zp) { // Currently writing a file (or meta data) if(rcmd==CMD_APPEND) { int app; //logp("rlen: %d\n", rlen); if((rb->zp && (app=gzwrite(rb->zp, rbuf, rlen))<=0) || (rb->fp && (app=fwrite(rbuf, 1, rlen, rb->fp))<=0)) { logp("error when appending: %d\n", app); async_write_str(CMD_ERROR, "write failed"); ret=-1; } do_filecounter_recvbytes(cntr, rlen); } else if(rcmd==CMD_END_FILE) { // Finished the file. // Write it to the phase2 file, and free the // buffers. if(close_fp(&(rb->fp))) { logp("error closing delta for %s in receive\n", rb->path); ret=-1; } if(gzclose_fp(&(rb->zp))) { logp("error gzclosing delta for %s in receive\n", rb->path); ret=-1; } rb->endfile=rbuf; rb->elen=rlen; rbuf=NULL; if(!ret && rb->receivedelta && finish_delta(rb, working, deltmppath)) ret=-1; else if(!ret) { if(sbuf_to_manifest(rb, p2fp, NULL)) ret=-1; else { char cmd=rb->cmd; if(rb->receivedelta) do_filecounter_changed(cntr, cmd); else do_filecounter(cntr, cmd, 0); if(*last_requested && !strcmp(rb->path, *last_requested)) { free(*last_requested); *last_requested=NULL; } } } if(!ret) { char *cp=NULL; cp=strchr(rb->endfile, ':'); if(rb->endfile) do_filecounter_bytes(cntr, strtoull(rb->endfile, NULL, 10)); if(cp) { // checksum stuff goes here } } free_sbuf(rb); } else { logp("unexpected cmd from client while writing file: %c %s\n", rcmd, rbuf); ret=-1; } } // Otherwise, expecting to be told of a file to save. else if(rcmd==CMD_DATAPTH) { rb->datapth=rbuf; rbuf=NULL; } else if(rcmd==CMD_STAT) { rb->statbuf=rbuf; rb->slen=rlen; rbuf=NULL; } else if(filedata(rcmd)) { rb->cmd=rcmd; rb->plen=rlen; rb->path=rbuf; rbuf=NULL; if(rb->datapth) { // Receiving a delta. if(start_to_receive_delta(rb, working, deltmppath, cconf)) { logp("error in start_to_receive_delta\n"); ret=-1; } } else { // Receiving a whole new file. if(start_to_receive_new_file(rb, datadirtmp, dpth, cntr, cconf)) { logp("error in start_to_receive_new_file\n"); ret=-1; } } } else if(rcmd==CMD_GEN && !strcmp(rbuf, "okbackupphase2end")) { ret=1; //logp("got okbackupphase2end\n"); } else if(rcmd==CMD_INTERRUPT) { // Interrupt - forget about the last requested file // if it matches. Otherwise, we can get stuck on the // select in the async stuff, waiting for something // that will never arrive. if(*last_requested && !strcmp(rbuf, *last_requested)) { free(*last_requested); *last_requested=NULL; } } else { logp("unexpected cmd from client while expecting a file: %c %s\n", rcmd, rbuf); ret=-1; } if(rbuf) { free(rbuf); rbuf=NULL; } } //logp("returning: %d\n", ret); return ret; }
// returns 1 for finished ok. static int do_stuff_to_receive(struct asfd *asfd, struct sdirs *sdirs, struct conf *cconf, struct sbuf *rb, FILE *p2fp, struct dpthl *dpthl, char **last_requested) { struct iobuf *rbuf=asfd->rbuf; iobuf_free_content(rbuf); // This also attempts to write anything in the write buffer. if(asfd->as->rw(asfd->as)) { logp("error in async_rw\n"); return -1; } if(!rbuf->buf) return 0; if(rbuf->cmd==CMD_WARNING) { logp("WARNING: %s\n", rbuf->buf); cntr_add(cconf->cntr, rbuf->cmd, 0); } else if(rb->burp1->fp || rb->burp1->zp) { // Currently writing a file (or meta data) if(rbuf->cmd==CMD_APPEND) { if(deal_with_receive_append(asfd, rb, cconf)) goto error; } else if(rbuf->cmd==CMD_END_FILE) { if(deal_with_receive_end_file(asfd, sdirs, rb, p2fp, cconf, last_requested)) goto error; } else { iobuf_log_unexpected(rbuf, __func__); goto error; } } // Otherwise, expecting to be told of a file to save. else if(rbuf->cmd==CMD_DATAPTH) { iobuf_copy(&rb->burp1->datapth, rbuf); rbuf->buf=NULL; } else if(rbuf->cmd==CMD_ATTRIBS) { iobuf_copy(&rb->attr, rbuf); rbuf->buf=NULL; } else if(filedata(rbuf->cmd)) { iobuf_copy(&rb->path, rbuf); rbuf->buf=NULL; if(rb->burp1->datapth.buf) { // Receiving a delta. if(start_to_receive_delta(sdirs, cconf, rb)) { logp("error in start_to_receive_delta\n"); goto error; } } else { // Receiving a whole new file. if(start_to_receive_new_file(asfd, sdirs, cconf, rb, dpthl)) { logp("error in start_to_receive_new_file\n"); goto error; } } } else if(rbuf->cmd==CMD_GEN && !strcmp(rbuf->buf, "okbackupphase2end")) goto end_phase2; else if(rbuf->cmd==CMD_INTERRUPT) { // Interrupt - forget about the last requested file // if it matches. Otherwise, we can get stuck on the // select in the async stuff, waiting for something // that will never arrive. if(*last_requested && !strcmp(rbuf->buf, *last_requested)) { free(*last_requested); *last_requested=NULL; } } else { iobuf_log_unexpected(rbuf, __func__); goto error; } return 0; end_phase2: return 1; error: return -1; }
// return 1 to say that a file was processed static int maybe_process_file(struct asfd *asfd, struct sdirs *sdirs, struct conf *cconf, struct sbuf *cb, struct sbuf *p1b, FILE *ucfp, struct dpthl *dpthl) { int pcmp; if(!(pcmp=sbuf_pathcmp(cb, p1b))) { int oldcompressed=0; // If the file type changed, I think it is time to back it // up again (for example, EFS changing to normal file, or // back again). if(cb->path.cmd!=p1b->path.cmd) return process_new_file(sdirs, cconf, cb, p1b, ucfp, dpthl); // mtime is the actual file data. // ctime is the attributes or meta data. if(cb->statp.st_mtime==p1b->statp.st_mtime && cb->statp.st_ctime==p1b->statp.st_ctime) { // got an unchanged file //logp("got unchanged file: %s %c %c\n", cb->path, cb->cmd, p1b->cmd); return process_unchanged_file(cb, ucfp, cconf); } if(cb->statp.st_mtime==p1b->statp.st_mtime && cb->statp.st_ctime!=p1b->statp.st_ctime) { // File data stayed the same, but attributes or meta // data changed. We already have the attributes, but // may need to get extra meta data. if(cb->path.cmd==CMD_ENC_METADATA || p1b->path.cmd==CMD_ENC_METADATA // TODO: make unencrypted metadata use the librsync || cb->path.cmd==CMD_METADATA || p1b->path.cmd==CMD_METADATA || cb->path.cmd==CMD_VSS || p1b->path.cmd==CMD_VSS || cb->path.cmd==CMD_ENC_VSS || p1b->path.cmd==CMD_ENC_VSS || cb->path.cmd==CMD_VSS_T || p1b->path.cmd==CMD_VSS_T || cb->path.cmd==CMD_ENC_VSS_T || p1b->path.cmd==CMD_ENC_VSS_T || cb->path.cmd==CMD_EFS_FILE || p1b->path.cmd==CMD_EFS_FILE) return process_new_file(sdirs, cconf, cb, p1b, ucfp, dpthl); // On Windows, we have to back up the whole file if // ctime changed, otherwise things like permission // changes do not get noticed. So, in that case, fall // through to the changed stuff below. // Non-Windows clients finish here. else if(!cconf->client_is_windows) return process_unchanged_file(cb, ucfp, cconf); } // Got a changed file. //logp("got changed file: %s\n", p1b->path); // If either old or new is encrypted, or librsync is off, // we need to get a new file. if(!cconf->librsync || cb->path.cmd==CMD_ENC_FILE || p1b->path.cmd==CMD_ENC_FILE || cb->path.cmd==CMD_ENC_METADATA || p1b->path.cmd==CMD_ENC_METADATA || cb->path.cmd==CMD_EFS_FILE || p1b->path.cmd==CMD_EFS_FILE // TODO: make unencrypted metadata use the librsync || cb->path.cmd==CMD_METADATA || p1b->path.cmd==CMD_METADATA || cb->path.cmd==CMD_VSS || p1b->path.cmd==CMD_VSS || cb->path.cmd==CMD_ENC_VSS || p1b->path.cmd==CMD_ENC_VSS || cb->path.cmd==CMD_VSS_T || p1b->path.cmd==CMD_VSS_T || cb->path.cmd==CMD_ENC_VSS_T || p1b->path.cmd==CMD_ENC_VSS_T) return process_new_file(sdirs, cconf, cb, p1b, ucfp, dpthl); // Get new files if they have switched between compression on // or off. if(cb->burp1->datapth.buf && dpthl_is_compressed(cb->compression, cb->burp1->datapth.buf)) oldcompressed=1; if( ( oldcompressed && !cconf->compression) || (!oldcompressed && cconf->compression)) return process_new_file(sdirs, cconf, cb, p1b, ucfp, dpthl); // Otherwise, do the delta stuff (if possible). if(filedata(p1b->path.cmd)) { if(process_changed_file(asfd, sdirs, cconf, cb, p1b, sdirs->currentdata)) return -1; } else { if(changed_non_file(p1b, ucfp, p1b->path.cmd, cconf)) return -1; } sbuf_free_content(cb); return 1; } else if(pcmp>0) { //logp("ahead: %s\n", p1b->path); // ahead - need to get the whole file if(process_new(sdirs, cconf, p1b, ucfp, dpthl)) return -1; // do not free return 1; } else { //logp("behind: %s\n", p1b->path); // behind - need to read more from the old // manifest // Count a deleted file - it was in the old manifest but not // the new. cntr_add_deleted(cconf->cntr, cb->path.cmd); } return 0; }