/*
* rw_dungeon
* セーブデータからのダンジョン情報の保存と復元
*/
void
rw_dungeon(FILE *fp, boolean rw)
{
short i, j;
char buf[ROGUE_COLUMNS];
if (rw) { // 書き込み時実行
for (i = 0; i < ROGUE_LINES; i++) {
r_write(fp, (char *) dungeon[i], (ROGUE_COLUMNS * sizeof(dungeon[0][0])));
for (j = 0; j < ROGUE_COLUMNS; j++) {
buf[j] = mvinch_rogue(i, j);
}
r_write(fp, buf, ROGUE_COLUMNS);
}
return;
} else { // 読み込み時実行
for (i = 0; i < ROGUE_LINES; i++) {
r_read(fp, (char *) dungeon[i], (ROGUE_COLUMNS * sizeof(dungeon[0][0])));
r_read(fp, buf, ROGUE_COLUMNS);
if ( i < ROGUE_LINES - 1 ) {
for (j = 0; j < ROGUE_COLUMNS; j++) {
mvaddch_rogue(i, j, (unsigned char) buf[j]);
}
} else {
print_stats(STAT_ALL);
}
}
return;
}
}
void
read_string(char *s, FILE *fp)
{
short n;
r_read(fp, (char *) &n, sizeof(short));
r_read(fp, s, n);
xxxx(s, n);
}
UWORD RES_read_entry(RF_class *RF, ULONG entry, void *dest, RF_entry_hdr *RHDR,
UWORD type) {
static RF_entry_hdr header;
ULONG len, hl;
UWORD tl, dl, n;
BYTE *tag;
DICT_entry *cur;
if (RF_flags(RF, entry) & (SA_UNUSED | SA_DELETED))
return (0);
header = *RF_header(RF, entry);
if (RHDR != NULL)
*RHDR = header;
len = header.data_size;
switch (type) {
case RTYP_DICTIONARY:
r_read(RF->file, &n, sizeof(UWORD));
len -= ((ULONG) sizeof(UWORD) * 2L);
hl = (ULONG) n * (ULONG) sizeof(ULONG);
len -= hl;
lseek(RF->file, hl, SEEK_CUR);
while (len) {
r_read(RF->file, &tl, sizeof(tl));
len -= (ULONG) (sizeof(tl) + tl);
if (!tl)
continue;
tag = (BYTE*) mem_alloc(tl);
r_read(RF->file, tag, (UWORD) tl);
cur = DICT_enter((DICT_class*) dest, tag, D_DEFHEAP);
mem_free(tag);
r_read(RF->file, &dl, sizeof(dl));
len -= (ULONG) (sizeof(dl) + dl);
if (dl) {
cur->def = mem_alloc((ULONG) dl);
r_read(RF->file, cur->def, (UWORD) dl);
} else
cur->def = NULL;
}
break;
default:
return (0);
}
return (1);
}
int main(void) {
int audiofd;
char *bp;
char buffer[BLKSIZE];
unsigned bytesneeded;
int bytesread;
if ((audiofd = open(AUDIO_DEVICE, O_NONBLOCK | O_RDWR)) == -1) {
perror("Failed to open audio device");
return 1;
}
bp = buffer;
bytesneeded = BLKSIZE;
while(bytesneeded != 0) {
bytesread = r_read(audiofd, bp, bytesneeded);
if ((bytesread == -1) && (errno != EAGAIN))
break;
if (bytesread > 0) {
bp += bytesread;
bytesneeded -= bytesread;
}
}
fprintf(stderr, "%d bytes read\n", BLKSIZE - bytesneeded);
return 0;
}
void
read_pack(object *pack, FILE *fp, boolean is_rogue)
{
object read_obj, *new_obj;
for (;;) {
r_read(fp, (char *) &read_obj, sizeof(object));
if (read_obj.ichar == 0) {
pack->next_object = (object *) 0;
break;
}
new_obj = alloc_object();
*new_obj = read_obj;
if (is_rogue) {
if (new_obj->in_use_flags & BEING_WORN) {
do_wear(new_obj);
} else if (new_obj->in_use_flags & BEING_WIELDED) {
do_wield(new_obj);
} else if (new_obj->in_use_flags & (ON_EITHER_HAND)) {
do_put_on(new_obj, ((new_obj->in_use_flags & ON_LEFT_HAND)
? 1 : 0));
}
}
pack->next_object = new_obj;
pack = new_obj;
}
}
int main(int argc, char *argv[]) {
int i;
char reqbuf[1];
int reqfd, seqfd;
long seqnum;
if (argc != 3) {
fprintf(stderr, "Usage: %s requestfifo sequencefifo\n", argv[0]);
return 1;
}
if ((reqfd = open(argv[REQUEST_FIFO], O_WRONLY)) == -1 ||
((seqfd = open(argv[SEQUENCE_FIFO], O_RDONLY)) == -1)) {
perror("Client failed to open a FIFO");
return 1;
}
for (i = 0; i < REPEAT_MAX; i++) {
reqbuf[0] = OK_CHAR;
sleep((int) (SLEEP_MAX * drand48()));
if (r_write(reqfd, reqbuf, 1) == -1) {
perror("Client failed to write request");
break;
}
if (r_read(seqfd, &seqnum, sizeof(seqnum)) != sizeof(seqnum)) {
fprintf(stderr, "Client failed to read full sequence number\n");
reqbuf[0] = ERROR_CHAR;
r_write(reqfd, reqbuf, 1);
break;
}
fprintf(stderr, "[%ld]:received sequence number %ld\n",
(long) getpid(), seqnum);
}
return 0;
}
void RF_delete_entry(RF_class *RF, ULONG entry) {
RF_entry_hdr RHDR;
ULONG blknum;
UWORD i;
OD_link *link;
blknum = (entry / (ULONG) OD_SIZE); // blknum = directory block #
i = (UWORD) (entry % (ULONG) OD_SIZE); // i = entry # within block
link = RF->root;
while (blknum--) {
link = link->next;
if (link == NULL)
return;
}
if (link->blk.flags[i] & (SA_UNUSED | SA_DELETED))
return;
lseek(RF->file, link->blk.index[i], SEEK_SET);
r_read(RF->file, &RHDR, sizeof(RF_entry_hdr));
link->blk.flags[i] |= SA_DELETED;
link->touched = 1;
RF->hdr.lost_space += RHDR.data_size;
RF->touched = 1;
RHDR.data_size = 0L;
lseek(RF->file, link->blk.index[i], SEEK_SET);
r_write(RF->file, &RHDR, sizeof(RF_entry_hdr));
}
rsexp r_compile_from_port (RState* r, rsexp port)
{
rsexp reader;
rsexp datum;
rsexp program;
ensure (reader = r_reader_new (r, port));
program = R_NULL;
datum = R_UNDEFINED;
while (TRUE) {
datum = r_read (reader);
if (r_failure_p (datum))
return R_FAILURE;
if (r_eof_object_p (datum))
break;
ensure (program = r_cons (r, datum, program));
}
return r_compile (r, program);
}
/* Fork a chain of processes */
int main(int argc, char *argv[])
{
char buf[] = "g";
pid_t child = 0;
int fd[2];
int i, n;
if (argc != 2) {
fprintf(stderr, "Usage: %s processes\n", argv[0]);
return 1;
}
n = atoi(argv[1]);
if (pipe(fd) == -1) { /* create pipe */
perror("Failed to create pipe");
return 1;
}
for (i = 0; i < n; i++) /* create fan of processes */
if ((child = fork()) <= 0)
break;
if (child > 0) { /* write synchronization chars to pipe */
for (i = 0; i < n; i++)
if (r_write(fd[1], buf, 1) != 1)
perror("Failed to write sync characters");
}
if (r_read(fd[0], buf, 1) != 1) /* synchronize here */
perror("Failed to read sync characters");
fprintf(stderr, "i:%d process ID:%ld parent ID:%ld child ID:%ld\n",
i, (long)getpid(), (long)getppid(), (long)child);
return 0;
}
/**
* attempts to read at most nbyte bytes from the open file descriptor fd into the
* buffer buf. The r_readtimed function behaves the same as r_read unless no bytes
* are available in a number of seconds given by seconds. If no bytes are available
* within the timeout period, r_readtimed returns –1 and sets errno to ETIME. If
* interrupted by a signal, r_readtimed restarts but maintains the original ending
* timeout.
*/
ssize_t r_readtimed(int fd, void *buf, size_t nbyte, double seconds) {
struct timeval timedone;
timedone = r_add2currenttime(seconds);
if (r_waitfdtimed(fd, timedone) == -1)
return (ssize_t)(-1);
return r_read(fd, buf, nbyte);
}
ssize_t readtimed(int fd, void *buf, size_t nbytes, double seconds)
{
struct timeval timedone;
timedone = add2currenttime(seconds);
if (waitfdtimed(fd, timedone) == -1)
return -1;
return r_read(fd, buf, nbytes);
}
ULONG RF_write_entry(RF_class *RF, ULONG entry, void *source,
RF_entry_hdr *RHDR, UWORD type) {
RF_entry_hdr cur, dummy;
ULONG blknum;
UWORD i;
OD_link *link;
blknum = (entry / (ULONG) OD_SIZE); // blknum = directory block #
i = (UWORD) (entry % (ULONG) OD_SIZE); // i = entry # within block
link = RF->root;
while (blknum--) {
link = link->next;
if (link == NULL)
return ((ULONG) -1L);
}
if (link->blk.flags[i] & SA_UNUSED)
return ((ULONG) -1L);
RF->touched = 1;
if (RHDR == NULL) {
dummy.data_size = 0L;
dummy.data_attrib = DA_TEMPORARY;
RHDR = &dummy;
}
if (type != RTYP_HOUSECLEAN) {
if (link->blk.flags[i] & SA_DELETED) {
link->blk.flags[i] &= (~SA_DELETED);
link->touched = 1;
}
RHDR->timestamp = RF->hdr.modify_time = current_time();
}
lseek(RF->file, link->blk.index[i], SEEK_SET);
if (link->blk.index[i] == RF->hdr.file_size) {
RF->hdr.file_size += (sizeof(RF_entry_hdr) + RHDR->data_size);
return (RES_store_resource(RF, entry, source, RHDR, type));
}
r_read(RF->file, &cur, sizeof(RF_entry_hdr));
if (RHDR->data_size > cur.data_size) {
RF->hdr.lost_space += (cur.data_size + sizeof(RF_entry_hdr));
link->blk.index[i] = RF->hdr.file_size;
link->touched = 1;
lseek(RF->file, 0L, SEEK_END);
RF->hdr.file_size += (sizeof(RF_entry_hdr) + RHDR->data_size);
} else {
RF->hdr.lost_space += (cur.data_size - RHDR->data_size);
lseek(RF->file, link->blk.index[i], SEEK_SET);
}
return (RES_store_resource(RF, entry, source, RHDR, type));
}
void
rw_rooms(FILE *fp, boolean rw)
{
short i;
for (i = 0; i < MAXROOMS; i++) {
rw ? r_write(fp, (char *) (rooms + i), sizeof(room)) :
r_read(fp, (char *) (rooms + i), sizeof(room));
}
}
void
rw_id(struct id id_table[], FILE *fp, int n, boolean wr)
{
short i;
for (i = 0; i < n; i++) {
if (wr) {
r_write(fp, (char *) &(id_table[i].value), sizeof(short));
r_write(fp, (char *) &(id_table[i].id_status),
sizeof(unsigned short));
write_string(id_table[i].title, fp);
} else {
r_read(fp, (char *) &(id_table[i].value), sizeof(short));
r_read(fp, (char *) &(id_table[i].id_status),
sizeof(unsigned short));
read_string(id_table[i].title, fp);
}
}
}
/**
* reads at most PIPE_BUF bytes from open file descriptor fromfd and writes the
* bytes read to the open file descriptor tofd. If successful, r_readwrite returns the
* number of bytes copied. If r_readwrite reaches end-of-file on fromfd, it returns
* 0. If unsuccessful, r_readwrite returns –1 and sets errno.
*/
int r_readwrite(int fromfd, int tofd) {
char buf[BLKSIZE];
int bytesread;
if ((bytesread = r_read(fromfd, buf, BLKSIZE)) < 0)
return -1;
if (bytesread == 0)
return 0;if (r_write(tofd, buf, bytesread) < 0)
return -1;
return bytesread;
}
/*
* rend_send_message
*
* Send a rendezvous message
*/
int rend_send_message(REND_MESSAGE *pmsg) {
int retval;
if(r_write(rend_pipe_to[WR_SIDE],pmsg,sizeof(REND_MESSAGE)) == -1)
return -1;
if((retval=r_read(rend_pipe_from[RD_SIDE],&retval,sizeof(int)) == -1))
return -1;
return retval;
}
void process_or_do_work(int fd1, int fd2) {
char buf[1024];
ssize_t bytesread;
for ( ; ; ) {
bytesread = r_read(fd1, buf, sizeof(buf));
if ((bytesread == -1) && (errno != EAGAIN))
return; /* a real error on fd1 */
else if (bytesread > 0) {
docommand(buf, bytesread);
continue;
}
bytesread = r_read(fd2, buf, sizeof(buf));
if ((bytesread == -1) && (errno != EAGAIN))
return; /* a real error on fd2 */
else if (bytesread > 0)
docommand(buf, bytesread);
else
dosomething(); /* input not available, do something else */
}
}
/*
This function is used to execute in a thread.
It will connect a server with hostname and port number.
It will send a full path of the named filename under the current working directory
to the server.
The server will return back a point to a number, if successful is 0, failed is 1.
The mutex lock is used to lock the communication process.
*/
void *threadconnect(void *arg) {
char flag[1];
int flag_num;
int bytescopied;
int communfd;
int error;
char compilepath[BLKSIZE];
int i =0;
const char *str_name;
struct connectpara *cp;
cp = (struct connectpara *)(arg);
u_port_t pn = 0;
char *hn = NULL;
char *fn = NULL;
pn = (*cp).portnumber;
hn = (*cp).hostname;
fn = (*cp).filename;
if ((communfd = u_connect(pn, hn)) == -1) {
perror("Failed to establish connection");
return NULL;
}
fprintf(stderr, "[%ld]:connection made to %s\n", (long)getpid(), hn);
str_name = fn;
getcwd(compilepath, BLKSIZE);
strcat(compilepath, "/");
strcat(compilepath, str_name);
strcat(compilepath, "\n");
if(r_write(communfd, compilepath, strlen(compilepath)) < 0) {
fprintf(stderr, "Could not write to communfd\n");
return NULL;
}
if ((i = r_read(communfd, flag, 1)) < 0) { //read flag from STDOUT_FILENO
fprintf(stderr, "Could not read flag from communfd.\n");
return NULL;
}
if(flag_num = (int) atoi(flag)) {
return &one;
}
else {
return &zero;
}
}
static bool_t xdr_std_read(xdr_s_type *xdr)
{
xdr->in_len = r_read(xdr->fd, (void *)xdr->in_msg, RPCROUTER_MSGSIZE_MAX);
if (xdr->in_len < 0) return FALSE;
if (xdr->in_len < (RPC_OFFSET+2)*4) {
xdr->in_len = -1;
return FALSE;
}
xdr->in_next = (RPC_OFFSET+2)*4;
return TRUE;
}
int copyfile(int fromfd, int tofd) {
char buf[BLKSIZE];
int bytesread, byteswritten;
int totalbytes = 0;
for ( ; ; ) {
if ((bytesread = r_read(fromfd, buf, BLKSIZE)) <= 0)
break;
if ((byteswritten = r_write(tofd, buf, bytesread)) == -1)
break;
totalbytes += byteswritten;
}
return totalbytes;
}
char *shell::passToLocator(const char*command){
//fprintf(stderr,"passToLocator\n");
int bytesSent, bytesRead=-1, myError;
char buffer[MAXBUFFER];
char *newCommand;
sem_wait(locatorAccessSemaphore); //I need you tonight.
//fprintf(stderr,"Access Semaphore received.\n");
bytesSent=r_write(processToLocatorThreadPipe[1], (void*)command, (std::strlen(command)+1));
bytesRead=r_read(locatorThreadToProcessPipe[0], (void*)buffer, MAXBUFFER);
//fprintf(stderr,"Bytes read: %d!\n", bytesRead);
sem_post(locatorAccessSemaphore); //Let's go our separate ways.
//fprintf(stderr,"Access Semaphore returned.\n");
newCommand=new char[std::strlen(buffer)+1];
std::strcpy(newCommand,buffer);
return newCommand;
}
void monitorselect(int fd[], int numfds) {
char buf[BUFSIZE];
int bytesread;
int i;
int maxfd;
int numnow, numready;
fd_set readset;
maxfd = 0; /* set up the range of descriptors to monitor */
for (i = 0; i < numfds; i++) {
if ((fd[i] < 0) || (fd[i] >= FD_SETSIZE))
return;
if (fd[i] >= maxfd)
maxfd = fd[i] + 1;
}
numnow = numfds;
while (numnow > 0) { /* continue monitoring until all are done */
FD_ZERO(&readset); /* set up the file descriptor mask */
for (i = 0; i < numfds; i++)
if (fd[i] >= 0)
FD_SET(fd[i], &readset);
numready = select(maxfd, &readset, NULL, NULL, NULL); /* which ready? */
if ((numready == -1) && (errno == EINTR)) /* interrupted by signal */
continue;
else if (numready == -1) /* real select error */
break;
for (i = 0; (i < numfds) && (numready > 0); i++) { /* read and process */
if (fd[i] == -1) /* this descriptor is done */
continue;
if (FD_ISSET(fd[i], &readset)) { /* this descriptor is ready */
bytesread = r_read(fd[i], buf, BUFSIZE);
numready--;
if (bytesread > 0)
docommand(buf, bytesread);
else { /* error occurred on this descriptor, close it */
r_close(fd[i]);
fd[i] = -1;
numnow--;
}
}
}
}
for (i = 0; i < numfds; i++)
if (fd[i] >= 0)
r_close(fd[i]);
}
static void alarm_handle_ev_cb(int fd,short event_type,void *arg)
{
int ret;
char buff[ALARM_BUFF_SIZE];
struct ISIL_EV_TASK * ev_task = (struct ISIL_EV_TASK *)arg;
if(ev_task) {
ret = r_read(fd,(char *)buff,ALARM_BUFF_SIZE);
if(ret < 0 ) {
if( errno == ENOMEM) {
//TODO:
return ;
}
fprintf(stderr,"Read alarm data err .\n");
ev_task->release(ev_task);
return ;
}
else if( ret == 0 ) {
fprintf(stderr,"Get alarm date err .\n");
ev_task->release(ev_task);
DEBUG_FUNCTION();
return ;
}
else{
/*put here*/
if(ev_task->hook) {
ev_task->hook( (void *)buff,ev_task);
}
}
}
return ;
}
static void
rtp_session_fill_cb(gpointer unused_data, gpointer session_p)
{
RTP_session *rtp_s = (RTP_session*)session_p;
Resource *resource = rtp_s->track->parent;
BufferQueue_Consumer *consumer = rtp_s->consumer;
gulong unseen;
unseen = bq_consumer_unseen(consumer);
if (unseen >= MAX_RND_PACKAGES)
return;
while ((unseen = bq_consumer_unseen(consumer)) < 3*MAX_RND_PACKAGES)
{
if (r_read(resource) != RESOURCE_OK)
break;
}
}
static int scrape_contents(pid_t pid, int fd, int size, void* data)
{
int offset, retval;
retval = 0;
offset = r_lseek(pid, fd, 0, SEEK_CUR);
if (offset == -1)
goto out_err;
if (r_lseek(pid, fd, 0, SEEK_SET) < 0)
goto out_err;
if (r_read(pid, fd, data, size) < 0)
goto out_err_seek;
retval = 1;
out_err_seek:
r_lseek(pid, fd, offset, SEEK_SET);
out_err:
return retval;
}
void *shell::locatorThread(void *arguments){
int bytesRead,bytesSent=-1, myError;
char buffer[MAXBUFFER];
std::string fullCommandName;
while(running){
bytesRead=r_read(processToLocatorThreadPipe[0], buffer, MAXBUFFER);
//fprintf(stderr,"Bytes read: %d!\n", bytesRead);
//fprintf(stderr,"Buffer contents: %s\n", buffer);
buffer[bytesRead-1]=0; //Cap it with a null, just to make sure
fullCommandName=locatorFindFile(buffer);
//bytesRead=r_write(locatorThreadToProcessPipe[0], (void*)fullCommandName.c_str(), (fullCommandName.size()+1));
//fprintf(stderr,"File Location: %s\n", fullCommandName.c_str());
std::strcpy(buffer, fullCommandName.c_str());
//fprintf(stderr,"Buffer contents: %s\n", buffer);
bytesSent=r_write(locatorThreadToProcessPipe[1], buffer, std::strlen(buffer)+1);
//fprintf(stderr,"Bytes Sent: %d\n", bytesSent);
fullCommandName.clear();
}
return NULL;
}
/* Read from infd and write to outfd until an error or end-of-file occurs */
static void readwriteall(int infd, int outfd) {
char buf[RWBUFSIZE];
int bytes_read;
while ((bytes_read = r_read(infd, buf, RWBUFSIZE)) > 0) {
if (r_write(outfd, buf, bytes_read) != bytes_read) {
if (ldebug_flag)
fprintf(stderr, "Pipe write error\n");
close(infd);
close(outfd);
return;
}
}
if (bytes_read < 0) {
if (ldebug_flag)
fprintf(stderr, "Pipe read error\n");
}
close(infd);
close(outfd);
}
/**
* @brief Do the work of filling an RTP session with data
*
* @param unued_data Unused
* @param session_p The session parameter from rtp_session_fill
*
*
* @internal This function is used to initialize @ref
* RTP_session::fill_pool.
*/
static void rtp_session_fill_cb(ATTR_UNUSED gpointer unused_data,
gpointer session_p)
{
RTP_session *session = (RTP_session*)session_p;
Resource *resource = session->track->parent;
BufferQueue_Consumer *consumer = session->consumer;
gulong unseen;
const gulong buffered_frames = resource->srv->srvconf.buffered_frames;
while ( (unseen = bq_consumer_unseen(consumer)) < buffered_frames ) {
#if 0
fprintf(stderr, "calling read_packet from %p for %p[%s] (%u/%d)\n",
session,
resource, resource->info->mrl,
unseen, buffered_frames);
#endif
if ( r_read(resource) != RESOURCE_OK )
break;
}
}
RF_entry_hdr *RF_header(RF_class *RF, ULONG entry) {
static RF_entry_hdr RHDR;
ULONG blknum;
UWORD i;
OD_link *link;
blknum = (entry / (ULONG) OD_SIZE); // blknum = directory block #
i = (UWORD) (entry % (ULONG) OD_SIZE); // i = entry # within block
link = RF->root;
while (blknum--) {
link = link->next;
if (link == NULL)
return (NULL);
}
if (link->blk.flags[i] & SA_UNUSED)
return (NULL);
lseek(RF->file, link->blk.index[i], SEEK_SET);
r_read(RF->file, &RHDR, sizeof(RF_entry_hdr));
return (&RHDR);
}
ssize_t
rRead (struct r_file *file, char *buffer, ssize_t size) {
int status = 0 , ret = -1 , siz = 0 , flage = 0;
unsigned long temp_size = 0 , bytes_read = 0 , temp_size1 = 0;
unsigned long counter = 0;
temp_size = size;
if (temp_size > 0) {
if (file != NULL) {
if (file->write_flag == 1) {
printf ("ERROR: File is Open in Write mode\n");
goto out;
}
/*if size is greater then 1024, then we have to
* repeatedly call the r_read function as server can
* send only 1024 bytes per request*/
if (temp_size > 1020) {
temp_size1 = size;
flage = 1;
loop:
if (temp_size > 1020) {
size = 1020;
temp_size -= 1020;
} else {
size = temp_size;
temp_size = 0;
}
}
siz = r_read (file , buffer , size);
if (siz == -1) {
/*checking the enum to print the error*/
/*if error occures the buffer will only
* contain error enum*/
status = atoi(buffer);
if (status == file_not_open) {
printf ("ERROR: File Not Open\n");
printf ("\tRead failed\n");
} else if (status == not_enough_content) {
if (flage == 1)
goto message;
printf ("ERROR: Not Enough Content\n");
} else
printf ("ERROR: Read Failed");
ret = -1;
goto out;
} else if (siz < size) {
if (flage != 1) {
printf ("File Contains only:");
printf("%d bytes\n" , siz);
printf ("File Content :\n\n%s\n\n",
buffer);
ret = 0;
goto out;
} else if (flage == 1) {
printf ("%s" , buffer);
counter += siz;
ret = 0;
goto message;
}
} else {
if (flage == 1) {
printf ("%s" , buffer);
counter += siz;
if (counter == temp_size1) {
ret = 0;
goto message;
} else {
goto loop;
}
} else {
printf ("File Content :\n\n%s\n\n"
, buffer);
ret = 0;
goto out;
}
}
} else
printf ("ERROR: File Not Open\n\n");
} else
printf ("ERROR: Please Enter a Valid Size\n\n");
message:
if (flage == 1) {
if (counter == temp_size1)
printf ("Total Contents read = %lu" , counter);
else
printf ("File only Contain : %lu bytes\n" , counter);
flage = 0;
}
out:
memset(buffer , 0 , sizeof(buffer));
return ret;
}
