_WCRTLINK int __F_NAME(chmod,_wchmod)( const CHAR_TYPE *pathname, int pmode ) /***************************************************************************/ { #ifdef __WIDECHAR__ char mbPath[MB_CUR_MAX * _MAX_PATH]; if( wcstombs( mbPath, pathname, sizeof( mbPath ) ) == -1 ) { mbPath[0] = '\0'; } return( chmod( mbPath, pmode ) ); #else unsigned attr; if( _dos_getfileattr( __F_NAME(pathname,mbPath), &attr ) ) { return( -1 ); } attr &= ~_A_RDONLY; if( !( pmode & S_IWRITE ) ) { attr |= _A_RDONLY; } if( _dos_setfileattr( __F_NAME(pathname,mbPath), attr ) ) { return( -1 ); } return( 0 ); #endif }
LOCAL void PROC do_mask (char *pathend) { static struct find_t fi; adds (pathend, mask); if (_dos_findfirst (path, findattr, &fi)) return; do { const char *p; p = fi.name-1; do p++; while (*p == '.'); if (*p == '\0') continue; /* name == dots */ adds (pathend, fi.name); found++; { ATTR attr = attr2str (OLD_ATTR, fi.attrib); if (*NEW_PART != '\0') { attr = (attr & attr_keep) | attr_set; if (_dos_setfileattr (path, attr2str (NEW_ATTR, attr) & (ATTR)~_A_SUBDIR)) { sayerror (E_ACCESS, "access denied", path); continue; } } } say (info, path); } while (_dos_findnext (&fi) == 0); }
BOOL MYRTLEXP SetFileAttr( CONSTSTR fname,ATTR_TYPE v ) { #if defined(__GNUC__) || defined(__QNX__) CLR_FLAG( v,flDirectory ); #else #if defined(__HDOS__) CLR_FLAG( v,FA_DIREC | FA_LABEL ); #else #if defined(__HWIN16__) CLR_FLAG( v,FA_DIREC | FA_LABEL ); #else #if defined(__HWIN32__) CLR_FLAG( v,FILE_ATTRIBUTE_DIRECTORY ); #else #error ERR_PLATFORM #endif #endif #endif #endif #if defined(__GNUC__) || defined(__QNX__) return FIO_CHMOD(fname,v); #else #if defined(__REALDOS__) return _dos_setfileattr(fname,v) == 0; #else #if defined(__PROTDOS__) return dos_setfileattr(fname,v) == 0; #else #if defined(__BCWIN16__) return _dos_setfileattr(fname,v) == 0; #else #if defined(__HWIN32__) return SetFileAttributes(fname,v) != 0; #else #error ERR_PLATFORM #endif #endif #endif #endif #endif }
void ResetArchives( copy_entry *list ) { copy_entry *next; #ifndef __UNIX__ unsigned attr; #endif while( list != NULL ) { next = list->next; #ifndef __UNIX__ if( _dos_getfileattr( list->src, &attr ) == 0 ) { _dos_setfileattr( list->src, attr & ~_A_ARCH ); } #endif free( list ); list = next; } }
/* DoRMdir - perform RM on a specified directory */ void DoRMdir( const char *dir ) { unsigned attribute; int rc; if( ( rc = rmdir( dir ) ) == -1 ) { _dos_getfileattr( dir, &attribute ); if( attribute & _A_RDONLY ) { if( fflag ) { _dos_setfileattr( dir, _A_NORMAL ); rc = rmdir( dir ); } else { PrintALineThenDrop( "Directory %s is read-only, use -f", dir ); error_occured = 1; } } } if( rc == -1 ) { PrintALineThenDrop( "Unable to delete directory %s", dir ); error_occured = 1; } else if( !sflag ) PrintALine( "Deleting directory %s", dir ); }
signed char do_restore(nwBackupParms * parms, char * remote_name, char * local_dir, char * logfile) { char ctrl_file_name[L_tmpnam]; FILE * ctrl_file; dirStack_t dstack; dirStruct_t dummy_curr_dir; fileStruct_t dummy_curr_file; nwBackupCodes nw_rc = SUCCESS; int do_restore_rc = 0; int path_eostr; char current_file_name[FILENAME_MAX]; char * path, * path_and_file, * unix_path, \ * unix_path_and_file, * file_buffer, * in_buffer; uint8_t * ctrl_buffer; path = malloc(129 * 4); file_buffer = malloc(FILE_BUF_SIZE); in_buffer = malloc(OUTBUF_SIZE); ctrl_buffer = malloc(BUFSIZ); /* Should be more than enough... handle dynamically sizing it later. */ //dummy_outbuf = calloc(OUTBUF_SIZE, 1); //This doesn't set the first and third byte //to zero! if(path == NULL || file_buffer == NULL || in_buffer == NULL || ctrl_buffer == NULL) { fprintf(stderr, "Could not allocate memory for path or file buffers!\n"); return -1; } /* Don't bother freeing till end of program- if error, program will terminate soon anyway! */ path_and_file = path + 129; unix_path = path_and_file + 129; unix_path_and_file = unix_path + 129; if(initDirStack(&dstack)) { fprintf(stderr, "Directory Stack Initialization failed!\n"); return -2; } if(!strcpy(path, local_dir)) /* if(strncpy(path, argv[1], DIR_MAX_PATH + 1) >= (DIR_MAX_PATH + 1)) */ { /* Shouldn't fail... but Heartbleed convinces me to code defensively. */ fprintf(stderr, "Specified path name is too long...\n" "Actually if we're got this error on DOS, we have more serious\n" "trouble than just a bad path!\n"); } path_eostr = strlen(path); if(path[path_eostr - 1] == 92) { /* Backslash */ path[path_eostr - 1] = '\0'; local_dir[path_eostr - 1] = '\0'; /* We will need local dir again! */ path_eostr--; /* path_eostr now points to the root path's NULL terminator. */ } //full_unix_path = malloc(strlen(parms-> strlen(remote_name) + ); /* If doing an absolute-path restore, the first push should be deferred until the control file header is read. */ if(pushDir(&dstack, &dummy_curr_dir, path)) { fprintf(stderr, "Initial directory push failed!\n"); return -3; } if(tmpnam(ctrl_file_name) == NULL) { fprintf(stderr, "Attempt to allocate tmpnam() for receiving CONTROL failed!\n"); return -4; } ctrl_file = fopen(ctrl_file_name, "wb+"); if(ctrl_file == NULL) { fprintf(stderr, "Attempt to open temp file for receiving CONTROL failed!\n"); return -5; } nw_rc = initRemote(parms); if(nw_rc != SUCCESS) { do_restore_rc = -6; } nw_rc = chDirRemote(remote_name); if(!(nw_rc == SUCCESS)) { do_restore_rc = -7; } if(!do_restore_rc) { /* Grab the control file from the server */ fprintf(stderr, "Receiving control file from the server (no retry)...\n"); setvbuf(ctrl_file, file_buffer, _IOFBF, FILE_BUF_SIZE); if(restore_file(ctrl_file, "CONTROL.NFO", in_buffer, OUTBUF_SIZE)) { fprintf(stderr, "Couldn't receive control file (%s) to the server. Supply" "the control file manually (not implemented) and try again.\n", ctrl_file_name); do_restore_rc = -8; } else { /* Control file was successfully grabbed. We can continue. */ ctrlEntryType_t entry_type; int8_t all_dirs_restored = 0; unsigned int attr, time, date; long unsigned int size; fprintf(stderr, "Control file received successfully from the server.\n"); fclose(ctrl_file); /* Assume this doesn't fail for now */ ctrl_file = fopen(ctrl_file_name, "rb"); entry_type = getNextEntry(ctrl_file, ctrl_buffer, BUFSIZ); while(!all_dirs_restored && do_restore_rc == 0) { FILE * curr_file; int temp; switch(entry_type) { case CTRL_HEADER: /* For now, absolute-path restores are disabled. Restores are relative to the directory in which the program is invoked. In effect, this code does nothing! */ //parseHeaderEntry(ctrl_buffer, path); /* if(pushDir(&dstack, &dummy_curr_dir, path)) { fprintf(stderr, "Initial directory push failed!\n"); do_restore_rc = -16; } */ fprintf(stderr, "Root directory: %s\n", path); break; case CTRL_DIR: temp = parseDirEntry(ctrl_buffer, current_file_name, &attr, &time, &date, &size); /* Change to snprintf soon */ sprintf(path_and_file, "%s\\%s", path, current_file_name); strcpy(path, path_and_file); unix_path[0] = '\0'; /* Skip the leading separator for now... */ if(createUnixName(unix_path, &path[path_eostr + 1]) == NULL) { fprintf(stderr, "Unix directory name creation failed!\n"); do_restore_rc = -9; break; } /* fprintf(stderr, "Return code: %d Curr directory: %s, Attr: %hu\nUnix name: %s\n",\ temp, path, attr, unix_path); */ if(_mkdir(path)) { fprintf(stderr, "Directory creation failed (%s)!\n", path); do_restore_rc = -10; } else { int dos_handle; fprintf(stderr, "Directory created: %s\n", path); if(_dos_open(path, O_RDONLY, &dos_handle)) { fprintf(stderr, "Warning: Could not open directory to set attributes!\n"); } else { if(_dos_setftime(dos_handle, date, time)) { fprintf(stderr, "Warning: Could not reset date/time on directory %s!\n", path); } _dos_close(dos_handle); if(_dos_setfileattr(path_and_file, attr)) { fprintf(stderr, "Warning: Could not set attributes on directory %s!\n", path); } } } //getchar(); break; case CTRL_FILE: /* Should not cause buffer overflow, since sizeof(current_file_name) set to FILENAME_MAX */ temp = parseFileEntry(ctrl_buffer, current_file_name, &attr, &time, &date, &size); /* Skip the leading separator for now... */ sprintf(path_and_file, "%s\\%s", path, current_file_name); if(!strcmp(path, local_dir)) { /* Don't copy a separator if the path is at the root... otherwise the server won't find the file and/or think the file is at the server's root! */ strcpy(unix_path_and_file, current_file_name); } else { sprintf(unix_path_and_file, "%s/%s", unix_path, current_file_name); } /* fprintf(stderr, "Return code: %d Curr directory: %s, Attr: %hu, Time %hu, Date %hu, Size %lu\n" \ "Unix directory: %s\n", temp, path_and_file, attr, time, date, size, unix_path_and_file); */ /* Receive file scope block. */ { int retry_count = 0; int8_t local_error = 0, rcv_done = 0; fprintf(stderr, "Receiving file %s...\n", unix_path_and_file); while(!rcv_done && !local_error && retry_count <= 3) { int8_t rcv_remote_rc; if(retry_count) { fprintf(stderr, "Retrying operation... (%d)\n", rcv_remote_rc); } curr_file = fopen(path_and_file, "wb"); setvbuf(curr_file, file_buffer, _IOFBF, FILE_BUF_SIZE); rcv_remote_rc = restore_file(curr_file, unix_path_and_file, in_buffer, OUTBUF_SIZE); //rcv_remote_rc = 0; fclose(curr_file); /* Close the file no matter what */ switch(rcv_remote_rc) { case 0: rcv_done = 1; break; case -2: fprintf(stderr, "Read error on file: %s! Not continuing.", path_and_file); local_error = 1; /* Local file error. */ break; case -1: /* Recoverable error. */ default: break; } retry_count++; } if(local_error) { /* If file error, we need to break out. */ do_restore_rc = -11; } else if(retry_count > 3) { do_restore_rc = -12; } else { /* File receive ok, try setting attributes now. */ int dos_handle; if(_dos_open(path_and_file, O_RDONLY, &dos_handle)) { fprintf(stderr, "Warning: Could not open file to set attributes!\n"); } else { if(_dos_setftime(dos_handle, date, time)) { fprintf(stderr, "Warning: Could not reset date/time on file %s!\n", path_and_file); } _dos_close(dos_handle); if(_dos_setfileattr(path_and_file, attr)) { fprintf(stderr, "Warning: Could not set attributes on file %s!\n", path_and_file); } } } } break; case CTRL_CDUP: /* Remove the deepest directory of the path, as long as we are not back at the invocation directory. */ //fprintf(stderr, "CDUP occurred.\n"); if(strcmp(path, local_dir)) { char * separator = strrchr(path, 92); if(separator != NULL) { /* Two characters need to be set to null because */ (* separator) = '\0'; //fprintf(stderr, "Path was stripped. ); } fprintf(stderr, "Directory change. New path is: %s\n", path); /* Skip the leading separator for now... we need to recreate the unix path in case a directory does not follow next! */ if(createUnixName(unix_path, &path[path_eostr + 1]) == NULL) { fprintf(stderr, "Unix directory name creation failed!\n"); do_restore_rc = -13; break; } //getchar(); } break; case CTRL_EOF: all_dirs_restored = 1; fprintf(stderr, "End of control file.\n"); break; default: fprintf(stderr, "Unexpected data from control file!\n"); do_restore_rc = -14; break; } entry_type = getNextEntry(ctrl_file, ctrl_buffer, BUFSIZ); fprintf(stderr, "\n"); } } } if(do_restore_rc) { fprintf(stderr, "Full restore failed with status code %d.\n", do_restore_rc); } else { fprintf(stderr, "Full restore completed successfully.\n"); } fclose(ctrl_file); closeRemote(); remove(ctrl_file_name); return do_restore_rc; }
/* * CopyOneFile - copy one file to another */ void CopyOneFile( char *dest, char *src ) { struct stat stat_s,stat_d; int i; unsigned srcattr; /* * first, check if source exists */ if( stat( src,&stat_s ) == - 1 ) { DropPrintALine("file \"%s\" not found.",src ); return; } _dos_getfileattr( src, &srcattr ); /* * check if the archive bit is set; if not, go back */ if( aflag ) { if( !(srcattr & _A_ARCH) ) { return; } } /* * if destination exists, make sure we can overwrite it */ if( stat( dest,&stat_d ) != -1 ) { #if !( defined( __OS2__ ) && defined( __386__ ) ) if( sameFile( dest, &stat_d, src, &stat_s ) ) { DropPrintALine( "%s and %s the same file, copy failed",src,dest ); return; } #endif if( !(stat_d.st_mode & S_IWRITE) ) { if( !fflag ) { DropPrintALine( "destination file %s is read only - use cp -f", dest); return; } else { chmod( dest, S_IWRITE | S_IREAD ); } } if( iflag ) { PrintALine( "overwrite %s (y\\n)", dest ); i = 0; while( i != 'y' && i != 'n' ) { i=getch(); } DropALine(); if( i=='n' ) { return; } } } /* * copy the file, and if it works, reset archive flag * of source (if needed) */ if( !GrabFile( src, &stat_s, dest, srcattr ) ) { return; } if( aflag ) { _dos_setfileattr( src, srcattr & (~_A_ARCH) ); } } /* CopyOneFile */
int ReceiveFile (char *FileName) { dword FileID = 0, FileSize = 0, CurSize = 0; bool FileNotReceive = true; int hFile = -1; ReceiveACluster (LEN_SEQ); // Init receive if (ErrAudit) printf ("|--Cluster--|-----I----|----II----|----III---|--Summary--|\n"); dword CurBlock = 0; while (FileNotReceive && !StopByUser) { CheckOnFreeComBuffer (); for (dword i = 0; i < MAX_AS_COM; i++) { if (ComTable [i].Semaphore == END_DEC_COM) { byte *ClusterBuffer = (byte*)ComTable [i].Buffer; FileHdr *filehdr = (FileHdr*)ClusterBuffer; if (CurBlock && filehdr->FileID != FileID) { //brk (); continue; // Go to next cluster } bool ClusterNotEmpty = true; dword CountBlock = 0; while (ClusterNotEmpty && FileNotReceive) { BlockHdr *pBH = (BlockHdr*) ((dword)ClusterBuffer + sizeof (FileHdr)); for (dword j = 0; j < filehdr->NumBlock; j++, pBH++) if (pBH->Number == CurBlock) break; // end loop // next block not found in current cluster if (pBH->Number != CurBlock) break; // Go to next cluster // find first block our file by name in file attributs if (!pBH->Number) { char *ArchiveName = (char*) ((dword)ClusterBuffer + pBH->ClusterOffset + sizeof (FileAttr)); FileAttr *fattr = (FileAttr*) ((dword)ClusterBuffer + pBH->ClusterOffset); // Other file - skip // if (stricmp (ArchiveName, FileName)); // { // brk (); // break; // Go to next cluster // } char NameBuff [128]; strcpy (NameBuff, ArchiveName); strcat (NameBuff, ".out"); // Create file if ((hFile = open (NameBuff, O_CREAT | O_BINARY | O_WRONLY, 0222)) == -1) return hFile; _dos_setfileattr (NameBuff, fattr->Attr); _dos_setftime (hFile, fattr->Date, fattr->Time); FileID = filehdr->FileID; // Set hook variable FileAttr *pFA = (FileAttr*)((dword)ClusterBuffer + pBH->ClusterOffset); FileSize = pFA->Size; } else { printf ("Receive block num:%6d, len:%6d\n", pBH->Number, pBH->Len); fflush (stdout); write (hFile, (byte*)((dword)ClusterBuffer + pBH->ClusterOffset), pBH->Len); CurSize += pBH->Len; } CurBlock++; CountBlock++; if (CountBlock == filehdr->NumBlock) { ClusterNotEmpty = false; ReceiveACluster (1); } if (FileSize == CurSize) { close (hFile); FileNotReceive = false; ClusterNotEmpty = false; } } // End while cluster not empty if (!ClusterNotEmpty && !StopByUser) { if (ErrAudit) { printf ("| %8d | %8d | %8d | %8d | %8d |\n", i, ComTable [i].ES.OrdinaryErr, ComTable [i].ES.DupletErr, ComTable [i].ES.TripletErr, ComTable [i].ES.OrdinaryErr + (ComTable [i].ES.DupletErr * 2) + (ComTable [i].ES.TripletErr * 3)); } FreeSemaphor (i); } } // end if find END_DECODE_COMMAND } // end for } // End while FileNotReceive PrintRFStatisics (); return 1; }