/* --- @mode_2@ --- * * * Arguments: @file_ptrs *fptrs@ = pointer struct of source and destination file * @off_t n_fptr_pos@ = the position of byte from where to be read * @off_t n_iso_block_no@ = the current block number being written * * Returns: the number of bytes read, @-1@ otherwise * * Use: Reads into the buffer and writes the buffer to destination file. */ off_t mode_2 ( file_ptrs* fptrs, off_t n_fptr_pos, off_t n_iso_block_no ) { int n_mode = 0; sub_header_block sub_header; /* Sub Header */ off_t (* mode_form [ 3 ] ) ( file_ptrs* fptrs, off_t n_fptr_pos, off_t n_iso_block_no ) = { &mode_2_form_1, &mode_2_form_2, &mode_0 }; memset ( &sub_header, 0, sizeof ( sub_header_block ) ); /* Move the file pointer to read the sub-header info */ set_file_pointer ( fptrs -> fsource, ( n_fptr_pos += ( off_t ) sizeof ( sync_header_block ) ) ); fread ( &sub_header, 1, sizeof ( sub_header_block ), fptrs -> fsource ); /* Revert back the file pointer as it has moved * till the sub-header (read 16 + 8 bytes of data) */ set_file_pointer ( fptrs -> fsource, ( n_fptr_pos -= ( off_t ) sizeof ( sync_header_block ) ) ); /*print ( ( void* ) &sub_header, sizeof ( sub_header_block ) );*/ if ( !memcmp ( sub_header.first_copy, sub_header.second_copy, 4 ) ) { /* Values { 0, 32, etc.. } 32 (5th bit set - Form 2), 0 - (5th bit not set - Form 1)*/ n_mode = ( ( n_mode = ( ( (int) *( sub_header.first_copy + 2 ) ) & 0x20 ) ) == 32 ) ? 1 : ( n_mode == 0 ) ? 0 : 2; n_fptr_pos = ( *( mode_form [ n_mode ] ) ) ( fptrs, n_fptr_pos, n_iso_block_no ); } else { /* It is Formless */ /* Mode 2 (2352): Syncheader (12), MSF / BCD (3), Mode (1), Data (2336) */ n_fptr_pos = ( *( mode_form [ 2 ] ) ) ( fptrs, n_fptr_pos, n_iso_block_no ); } return ( n_fptr_pos ); }
bool BufferedFile::open(const PathChar *name, const char *mode) { set_file_pointer(OsFile_open(name, mode)); OsFile_Handle fh = file_pointer(); set_file_size(fh == NULL ? 0 : OsFile_length(fh)); return (fh != NULL); }
PJ_DEF(pj_status_t) pj_file_getpos( pj_oshandle_t fd, pj_off_t *pos) { if (set_file_pointer(fd, 0, pos, FILE_CURRENT) != PJ_SUCCESS) { return PJ_RETURN_OS_ERROR(GetLastError()); } return PJ_SUCCESS; }
int BufferedFile::close() { if (file_pointer() != NULL) { int result = OsFile_close(file_pointer()); set_file_pointer(0); set_file_size(0); set_file_pos(0); set_index(0); set_count(0); return result; } else { return -1; } }
Tchannel OS_open_append_file (const char * filename) { Tchannel channel = (open_file (filename, FILE_NORMAL, (OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_CREATE_IF_NEW), CHANNEL_WRITE)); transaction_begin (); OS_channel_close_on_abort (channel); (void) set_file_pointer (channel, FILE_END, 0); transaction_commit (); return (channel); }
/* writes data to fcell file for either full or partial rows */ static void put_fp_data(int fd, char *null_buf, const void *rast, int row, int n, RASTER_MAP_TYPE data_type) { struct fileinfo *fcb = &R__.fileinfo[fd]; int compressed = (fcb->open_mode == OPEN_NEW_COMPRESSED); XDR *xdrs = &fcb->xdrstream; void *work_buf; if (row < 0 || row >= fcb->cellhd.rows) return; if (n <= 0) return; work_buf = G__alloca(fcb->cellhd.cols * fcb->nbytes + 1); if (compressed) set_file_pointer(fd, row); xdrmem_create(xdrs, work_buf, (unsigned int)fcb->nbytes * fcb->cellhd.cols, XDR_ENCODE); xdr_setpos(xdrs, 0); if (data_type == FCELL_TYPE) convert_float(xdrs, null_buf, rast, row, n); else convert_double(xdrs, null_buf, rast, row, n); xdr_destroy(&fcb->xdrstream); if (compressed) write_data_compressed(fd, row, work_buf, n); else write_data(fd, row, work_buf, n); G__freea(work_buf); }
PJ_DEF(pj_status_t) pj_file_setpos( pj_oshandle_t fd, pj_off_t offset, enum pj_file_seek_type whence) { DWORD dwMoveMethod; pj_off_t newPos; if (whence == PJ_SEEK_SET) dwMoveMethod = FILE_BEGIN; else if (whence == PJ_SEEK_CUR) dwMoveMethod = FILE_CURRENT; else if (whence == PJ_SEEK_END) dwMoveMethod = FILE_END; else { pj_assert(!"Invalid whence in file_setpos"); return PJ_EINVAL; } if (set_file_pointer(fd, offset, &newPos, dwMoveMethod) != PJ_SUCCESS) { return PJ_RETURN_OS_ERROR(GetLastError()); } return PJ_SUCCESS; }
CAMLprim value unix_lockf(value fd, value cmd, value span) { CAMLparam3(fd, cmd, span); OVERLAPPED overlap; intnat l_len; HANDLE h; OSVERSIONINFO version; LARGE_INTEGER cur_position; LARGE_INTEGER beg_position; LARGE_INTEGER lock_len; LARGE_INTEGER zero; DWORD err = NO_ERROR; version.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); if(GetVersionEx(&version) == 0) { invalid_argument("lockf only supported on WIN32_NT platforms: could not determine current platform."); } if(version.dwPlatformId != VER_PLATFORM_WIN32_NT) { invalid_argument("lockf only supported on WIN32_NT platforms"); } h = Handle_val(fd); l_len = Long_val(span); /* No matter what, we need the current position in the file */ zero.HighPart = zero.LowPart = 0; set_file_pointer(h, zero, &cur_position, FILE_CURRENT); /* All unused fields must be set to zero */ memset(&overlap, 0, sizeof(overlap)); if(l_len == 0) { /* Lock from cur to infinity */ lock_len.QuadPart = -1; overlap.OffsetHigh = cur_position.HighPart; overlap.Offset = cur_position.LowPart ; } else if(l_len > 0) { /* Positive file offset */ lock_len.QuadPart = l_len; overlap.OffsetHigh = cur_position.HighPart; overlap.Offset = cur_position.LowPart ; } else { /* Negative file offset */ lock_len.QuadPart = - l_len; if (lock_len.QuadPart > cur_position.QuadPart) { errno = EINVAL; uerror("lockf", Nothing); } beg_position.QuadPart = cur_position.QuadPart - lock_len.QuadPart; overlap.OffsetHigh = beg_position.HighPart; overlap.Offset = beg_position.LowPart ; } switch(Int_val(cmd)) { case 0: /* F_ULOCK - unlock */ if (! UnlockFileEx(h, 0, lock_len.LowPart, lock_len.HighPart, &overlap)) err = GetLastError(); break; case 1: /* F_LOCK - blocking write lock */ enter_blocking_section(); if (! LockFileEx(h, LOCKFILE_EXCLUSIVE_LOCK, 0, lock_len.LowPart, lock_len.HighPart, &overlap)) err = GetLastError(); leave_blocking_section(); break; case 2: /* F_TLOCK - non-blocking write lock */ if (! LockFileEx(h, LOCKFILE_FAIL_IMMEDIATELY | LOCKFILE_EXCLUSIVE_LOCK, 0, lock_len.LowPart, lock_len.HighPart, &overlap)) err = GetLastError(); break; case 3: /* F_TEST - check whether a write lock can be obtained */ /* I'm doing this by aquiring an immediate write * lock and then releasing it. It is not clear that * this behavior matches anything in particular, but * it is not clear the nature of the lock test performed * by ocaml (unix) currently. */ if (LockFileEx(h, LOCKFILE_FAIL_IMMEDIATELY | LOCKFILE_EXCLUSIVE_LOCK, 0, lock_len.LowPart, lock_len.HighPart, &overlap)) { UnlockFileEx(h, 0, lock_len.LowPart, lock_len.HighPart, &overlap); } else { err = GetLastError(); } break; case 4: /* F_RLOCK - blocking read lock */ enter_blocking_section(); if (! LockFileEx(h, 0, 0, lock_len.LowPart, lock_len.HighPart, &overlap)) err = GetLastError(); leave_blocking_section(); break; case 5: /* F_TRLOCK - non-blocking read lock */ if (! LockFileEx(h, LOCKFILE_FAIL_IMMEDIATELY, 0, lock_len.LowPart, lock_len.HighPart, &overlap)) err = GetLastError(); break; default: errno = EINVAL; uerror("lockf", Nothing); } if (err != NO_ERROR) { win32_maperr(err); uerror("lockf", Nothing); } CAMLreturn(Val_unit); }
void OS_file_set_position (Tchannel channel, off_t position) { if ((set_file_pointer (channel, FILE_BEGIN, position)) != position) OS2_error_anonymous (); }
off_t OS_file_position (Tchannel channel) { return (set_file_pointer (channel, FILE_CURRENT, 0)); }
/* --- @bin_2_iso@ --- * * * Arguments: @file_ptrs *fptrs@ = pointer struct of source and destination file * @image_struct *img_struct@ = struct of image pregap * * Returns: Zeor on success, @-1@ on error. * * Use: Return the detection of the image. */ int bin_2_iso ( file_ptrs* fptrs, image_struct* img_struct ) { off_t n_loop = 0; off_t n_loop_incrementer = 0; off_t n_img_size = 0; int n_return_value = ERROR; int n_mode = 0; long n_iso_block_no = 0; unsigned const char synch_pattern [ 12 ] = { 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00 }; sync_header_block header; /* Sync Header Block */ off_t (* mode [ 5 ] ) ( file_ptrs* fptrs, off_t n_fptr_pos, off_t n_iso_block_no ) = { &mode_0, &mode_1, &mode_2, &mode_2_form_1_headerless, &mode_2_form_2_headerless }; if ( NULL== fptrs -> fsource ) return ( n_return_value ); /* The source file pointer is empty */ if ( ( n_img_size = get_file_size ( fptrs -> fsource ) ) < 1 ) return ( n_return_value ); /* The image file is empty */ for ( n_loop = ( off_t ) img_struct -> pregap; n_loop < n_img_size; ) { progress_bar ( ( int ) ( ( ( n_loop + 1 ) * 100 ) / n_img_size ) ); /* Initalize for the loop */ memset ( &header, 0, sizeof ( sync_header_block ) ); /* Initialize the file pointer to the start point */ set_file_pointer ( fptrs -> fsource, n_loop ); fread ( &header, 1, sizeof ( sync_header_block ), fptrs -> fsource ); /*printf ("Image size :%ld\n", n_img_size ); printf ( "LOOP NO :%d\n", n_loop ); print ( ( void* ) &header, 16 );*/ /* Revert back the file pointer as it has moved the * file pointer till the header (read 16 bytes of data) */ set_file_pointer ( fptrs -> fsource, n_loop ); if ( !memcmp ( &synch_pattern, &header, 12 ) ) { n_iso_block_no++; /* Image has 12 BYTE SYNC HEADER */ n_mode = ( (char) ( *( header.msf_block.mode ) ) ); if ( ( n_mode > -1 ) && ( n_mode < 3 ) ) /* Mode { 0, 1, 2 } */ n_loop_incrementer = ( *( mode [ n_mode ] ) ) ( fptrs, n_loop, n_iso_block_no ); /* Increment to the next block */ else printf ( "Weird Mode \n" ); if ( 0 < n_loop_incrementer ) { if ( ( 2448 == img_struct -> block ) || ( 2368 == img_struct -> block ) ) { n_loop += n_loop_incrementer; n_loop += ( ( off_t ) img_struct -> block - n_loop_incrementer ); n_loop_incrementer = 0; } else n_loop += n_loop_incrementer; } } else if ( ( !memcmp ( &header, ( ( (unsigned char*) (&header) ) + 4 ), 4 ) ) && ( 2336 == img_struct -> block ) ) { int n_mode_no_header = 0; n_iso_block_no++; /*print ( ( void* ) &header, 8 );*/ n_mode_no_header = ( (int) *( ( (unsigned char*) (&header) ) + 2 ) ) & 0x20; n_mode_no_header = ( n_mode_no_header == 32 ) ? 1 : 0; n_loop += ( *( mode [ 3 + n_mode_no_header ] ) ) ( fptrs, n_loop, n_iso_block_no ); /* Increment to the next block */ } else { /* Image does not have any standard header */ /*print ( ( void* ) &header, 16 );*/ n_loop++; /* Increment to the next location */ /*n_loop += img_struct -> block;*/ /* Increment to the next block */ } } set_file_pointer ( fptrs -> fsource, ( off_t ) 0 ); n_return_value = AOK; progress_bar ( 100 ); printf ( "\n" ); return ( n_return_value ); }
static void put_data(int fd, char *null_buf, const CELL * cell, int row, int n, int zeros_r_nulls) { struct fileinfo *fcb = &R__.fileinfo[fd]; int compressed = fcb->cellhd.compressed; int len = compressed ? sizeof(CELL) : fcb->nbytes; unsigned char *work_buf, *wk; ssize_t nwrite; if (row < 0 || row >= fcb->cellhd.rows) return; if (n <= 0) return; work_buf = G__alloca(fcb->cellhd.cols * sizeof(CELL) + 1); wk = work_buf; if (compressed) set_file_pointer(fd, row); if (compressed) wk++; convert_int(wk, null_buf, cell, n, len, zeros_r_nulls); if (compressed) { unsigned char *wk = work_buf + 1; int nbytes = count_bytes(wk, n, len); unsigned char *compressed_buf; int total; if (fcb->nbytes < nbytes) fcb->nbytes = nbytes; /* first trim away zero high bytes */ if (nbytes < len) trim_bytes(wk, n, len, len - nbytes); total = nbytes * n; compressed_buf = G__alloca(total + 1); compressed_buf[0] = work_buf[0] = nbytes; /* then compress the data */ nwrite = compressed == 1 ? rle_compress(compressed_buf + 1, work_buf + 1, n, nbytes) : zlib_compress(compressed_buf + 1, work_buf + 1, n, nbytes); if (nwrite > 0) { nwrite++; if (write(fd, compressed_buf, nwrite) != nwrite) G_fatal_error(_("Error writing compressed data for row %d of <%s>"), row, fcb->name); } else { nwrite = nbytes * n + 1; if (write(fd, work_buf, nwrite) != nwrite) G_fatal_error(_("Error writing compressed data for row %d of <%s>"), row, fcb->name); } G__freea(compressed_buf); } else { nwrite = fcb->nbytes * n; if (write(fd, work_buf, nwrite) != nwrite) G_fatal_error(_("Error writing uncompressed data for row %d of <%s>"), row, fcb->name); } G__freea(work_buf); }