Пример #1
0
Файл: http.c Проект: zerix/mpv
/**
 * \brief read and process (i.e. discard *g*) a block of ultravox metadata
 * \param fd file descriptor to read from
 * \param sc streaming_ctrl_t whose buffer is consumed before reading from fd
 * \return number of real data before next metadata block starts or 0 on error
 *
 * You can use unsv://samples.mplayerhq.hu/V-codecs/VP5/vp5_artefacts.nsv to
 * test.
 */
static unsigned uvox_meta_read(int fd, streaming_ctrl_t *sc) {
  unsigned metaint;
  unsigned char info[6] = {0, 0, 0, 0, 0, 0};
  int info_read;
  do {
    info_read = my_read(fd, info, 1, sc);
    if (info[0] == 0x00)
      info_read = my_read(fd, info, 6, sc);
    else
      info_read += my_read(fd, &info[1], 5, sc);
    if (info_read != 6) // read error or eof
      return 0;
    // sync byte and reserved flags
    if (info[0] != 0x5a || (info[1] & 0xfc) != 0x00) {
      mp_msg(MSGT_DEMUXER, MSGL_ERR, "Invalid or unknown uvox metadata\n");
      return 0;
    }
    if (info[1] & 0x01)
      mp_msg(MSGT_DEMUXER, MSGL_WARN, "Encrypted ultravox data\n");
    metaint = info[4] << 8 | info[5];
    if ((info[3] & 0xf) < 0x07) { // discard any metadata nonsense
      char *metabuf = malloc(metaint);
      my_read(fd, metabuf, metaint, sc);
      free(metabuf);
    }
  } while ((info[3] & 0xf) < 0x07);
  return metaint;
}
Пример #2
0
void	put_in_tab(t_all *a)
{
  int	x;
  int	y;
  int	i;

  x = 0;
  y = 0;
  my_open(a);
  my_read(a);
  while (a->c != '\n')
    my_read(a);
  while ((i = my_read(a)) != 0)
    {
      if (a->c == '\n')
	{
	  y++;
	  x = 0;
	}
      if (a->c == '.' || a->c == 'o')
	{
	  a->tab[y][x] = a->c;
	  x++;
	}
    }
}
Пример #3
0
long int sock_read(net_sock_t *nsock, tbuffer_t *buf, size_t bpos, size_t len, Net_timeout_t tm)
{
    int err, ewait; // eno;
    apr_size_t nbytes;
//  Net_timeout_t end_time;
    network_sock_t *sock = (network_sock_t *)nsock;

    if (sock == NULL) return(-1);   //** If closed return
    if (sock->fd == NULL) return(-1);

//  end_time = apr_time_now() + tm;

    err = my_read(sock, buf, bpos, len, &nbytes);
    if (err != APR_SUCCESS) {
        ewait = sock_io_wait(sock, tm, SOCK_WAIT_READ);
        my_read(sock, buf, bpos, len, &nbytes);
//log_printf(10, "sock_read: ewait=%d err=%d nbytes=" I64T "\n", ewait, err, nbytes);
        if ((ewait == 1) && (nbytes < 1)) nbytes = -1;
    }

//eno = errno;
//if (nbytes == -1) log_printf(4, "sock_read: count=" ST " nbytes=%ld err=%d errno=%d\n", count, nbytes, err, errno);
//log_printf(15, "sock_read: count=" ST " nbytes=%ld err=%d\n", count, nbytes, err);
    return(nbytes);
}
Пример #4
0
void		read_archive(int fd, int v)
{
  t_file	f;
  char		*size;

  f.name = malloc(100);
  size = malloc(12);
  f.content = malloc(1);
  f.right = malloc(8);
  f.time = malloc(12);
  while (my_read(fd, &f.name, 100) > 0)
    {
      if (v)
	printf("%s, ", f.name);
      my_read(fd, &size, 12);
      f.size = gtnb(size);
      my_read(fd, &f.right, 8);
      my_read(fd, &f.time, 12);
      free(f.content);
      f.content = malloc(f.size);
      my_read(fd, &f.content, f.size);
      write_file(&f);
    }
  free_arch(&size, &f);
}
Пример #5
0
char		*get_next_line(const int fd, t_mysh *all)
{
  int		rd;
  char		*output;
  static int	i = 0;
  static char	*buffer = NULL;

  /*  if (fd == 0)
      return (empty_buffer(buffer));*/
  rd = 1;
  if (buffer == NULL || buffer[i] == '\0')
    if ((buffer = my_read(fd, &i, &rd, buffer)) == NULL)
      return (NULL);
  output = x_malloc(sizeof(output) * (BUF_SIZE + 1));
  all->gnl_j = 0;
  while (buffer[i] != '\n' && rd > 0)
    if (buffer[i] == '\0')
      {
	if ((buffer = my_read(fd, &i, &rd, buffer)) == NULL)
	  return (output);
	output = my_realloc(all->gnl_j, output);
      }
    else
      output[all->gnl_j++] = buffer[i++];
  output[all->gnl_j] = '\0';
  i++;
  return (output);
}
Пример #6
0
/* Function to read from a file from single indirect block */
int read_file_from_indirect_block(int file_size, inode * file_inode)
{
	int i,print_len;
	char buff[BS];
	si_block * si_block_object ;
	si_block_object = (si_block *) buff;

	my_read(si_block_object, BS, file_inode->single_indirect_block_offset);
	int remain_block = ceil((float) (file_size * 1.0)/ BS);

	print_len = BS;

	while(remain_block > 0){
		if(remain_block > BS / sizeof(int *)){
			for(i = 0;i < (BS / sizeof(int *)) - 1;i++ ){
				//printf("\n------------------- si_block[%d] at (%d)----------------------------\n",i,si_block_object->db_index[i]);
				print_data_block(print_len, si_block_object->db_index[i]);
				file_size -= BS;
			}
		}else{
			for(i = 0;i < remain_block ;i++ ){
				if(file_size < BS)
					print_len = file_size;
				//printf("\n------------------- si_block[%d] at (%d)----------------------------\n",i,si_block_object->db_index[i]);
				print_data_block(print_len, si_block_object->db_index[i]);
				file_size -= BS;
			}
		}
		my_read(si_block_object, BS, si_block_object->db_index[(BS / sizeof(int *)) - 1]);
		remain_block -= (BS / sizeof(int *)) - 1;
	}

	return 0;
}
Пример #7
0
main()
{
  int i, j;

  my_init(MEMORY_SIZE, PHYSICAL_MEM_LIMIT);
	/* The MEMORY SIZE is in megabytes */
	/* PHYSICAL MEMORY SIZE is in number of system pages */
	/* The page size on Sparc 4 and Sparc 5 is 4Kb */

  // dump_out();
  for (i = 0; i < NUM_BUFS; i++)
    {
      sbuf[i] = (char *)my_malloc(SMALL_BUF_SIZE);
      lbuf[i] = (char *)my_malloc(LARGE_BUF_SIZE);
      printf("The buffer small pointers is %d, and large pointer is
%d\n", (unsigned)sbuf[i], (unsigned)lbuf[i]);
      // dump_out();
    }

 
  // exit(1);
  for (i = 0; i < NUM_BUFS; i++)
    {
      memset(temp_buffer, 'A'+i, LARGE_BUF_SIZE);
      my_write(sbuf[i], SMALL_BUF_SIZE, temp_buffer);
      my_write(lbuf[i], LARGE_BUF_SIZE, temp_buffer);
    }

  read_start();


  // cout << "end of the read_start routine \n";
  my_read(lbuf[NUM_BUFS-1], LARGE_BUF_SIZE, temp_buffer);
  my_write(lbuf[0], LARGE_BUF_SIZE, temp_buffer);

  my_read(lbuf[NUM_BUFS - 1], LARGE_BUF_SIZE, temp_buffer);
  my_write(lbuf[1]+5, 3, temp_buffer);

  my_read(sbuf[NUM_BUFS-1], SMALL_BUF_SIZE, temp_buffer);
  my_write(sbuf[0], SMALL_BUF_SIZE, temp_buffer);

  my_read(sbuf[NUM_BUFS - 1], SMALL_BUF_SIZE, temp_buffer);
  my_write(sbuf[1]+5, 3, temp_buffer);

  read_start();


  for (i = 0; i < NUM_BUFS; i++) {
    my_free((void *) sbuf[i]);
    my_free((void *) lbuf[i]);
  }

  my_terminate();
}
Пример #8
0
/*
 * given an object that addresses a FILE, and a max count,
 * get a list of characters
 */
static wycc_obj* my_read(wycc_obj *itm, int max) {
    WY_OBJ_SANE(itm, "my_read");
    FILE *fil;
    size_t siz;
    char chr;
    long tmp;
    long cnt = 0;
    wycc_obj *mbr;
    wycc_obj *lst;

    if (itm->typ != Wy_Addr) {
	WY_PANIC("Help needed in my_read for type %d\n", itm->typ)
    };
    fil = (FILE *) itm->ptr;
    lst = wycc_list_new(10);
    while (feof(fil) == 0) {	/* could be skipped */
	siz = fread(&chr, 1, 1, fil);
	if (siz != 1) {
	    if (feof(fil)) {
		break;
	    };
	    WY_PANIC("Failed to read byte from file\n")
	};
	tmp = (long) chr;
	mbr = wycc_box_new(Wy_Char, (void *) tmp);
	wycc_list_add(lst, mbr);
	cnt++;
	if (cnt == max) {
	    break;
	};
    }
    return lst;
}

/*
 * given an object that addresses a FILE, get a list of characters
 */
wycc_obj* wycc__read_max(wycc_obj *itm, wycc_obj *max) {
    WY_OBJ_SANE(itm, "wycc__read_max itm");
    WY_OBJ_SANE(max, "wycc__read_max max");

    if (max->typ == Wy_Int) {
	return my_read(itm, (int) max->ptr);
    };
    if (max->typ == Wy_WInt) {
	return my_read(itm, 0);		// too big to matter
    };
    WY_PANIC("Help needed in wycc__read_max for type %d\n", max->typ)
}
Пример #9
0
int main(int argc, char *argv[])
{
	int fd;
	char write_buf[32] = "Hello world!";

	//在当前目录下创建文件example_63.c
	//if ((fd = creat ("example_63.c", S_IRWXU)) == -1) {
	if ((fd = open ("example_63.c", O_RDWR|O_CREAT|O_TRUNC, S_IRWXU)) == -1) {
	
		my_err ("open", errno);
	
	}

	else {
	
		printf ("create filr success!\n");
	
	}

	//写数据
	if (write (fd, write_buf, strlen(write_buf)) != strlen(write_buf)) {
	
		my_err ("write", errno);
	
	}

	my_read (fd);

	//演示文件间隔
	printf ("/*------------------------*/\n");

	if (lseek (fd, 10, SEEK_END) == -1) {
	
		my_err ("lseek", errno);
	
	}
	if (write (fd, write_buf, strlen(write_buf)) != strlen(write_buf)) {
	
		my_err ("write", errno);
	
	}

	my_read (fd);

	close (fd);

	return EXIT_SUCCESS;
}
Пример #10
0
ssize_t df_read(int fd, void *buf, size_t count)
{
	size_t read_so_far = 0;
	ssize_t read_this_time = 0;

	while (read_so_far < count) {
		if (dbg) {
			fprintf(stderr, READ_FMT, fd,
					buf + read_so_far, buf, read_so_far,
					count - read_so_far,
					count, read_this_time);
		}
		read_this_time = my_read(fd,
				buf + read_so_far,
				count - read_so_far);
		if (-1 == read_this_time)
			return -errno;
		if (0 == read_this_time)
			return 0;

		read_so_far += read_this_time;
	}

	assert(read_so_far == count);

	return read_so_far;
}
Пример #11
0
/*
 * Same as Kgio::PipeMethods#kgio_read, except EOFError is raised
 * on EOF without a backtrace.  This method is intended as a
 * drop-in replacement for places where IO#readpartial is used, and
 * may be aliased as such.
 */
static VALUE kgio_read_bang(int argc, VALUE *argv, VALUE io)
{
	VALUE rv = my_read(1, argc, argv, io);

	if (NIL_P(rv)) my_eof_error();
	return rv;
}
Пример #12
0
ssize_t
my_readline(int fd, void *vptr, size_t maxlen)
{
	size_t n, rc;
	char c, *ptr;
	Rline *tsd;

	if ( pthread_once(&rl_once, readline_once) != 0)
		err(1, "Problem with pthread_once");
	if ( (tsd = pthread_getspecific(rl_key)) == NULL ) {
		tsd = calloc(1, sizeof(Rline));
		if (tsd == NULL)
			err(1, "Problem with calloc");
		if ( pthread_setspecific(rl_key, tsd) != 0)
			err(1, "Problem with pthread_setspecific");
	}
	ptr = vptr;
	for (n=1; n < maxlen; n++) {
		if ( (rc = my_read(tsd, fd, &c)) == 1) {
			*ptr++ = c;
			if (c == '\n')
				break;
		}
		else if (rc == 0) { 	/* Got EOF */
			*ptr = 0;
			return (n - 1);
		}
		else
			return -1;
	}

	*ptr = 0;
	return n;
}
Пример #13
0
void sloop() {
	int rc;
	fd_set readfds, writefds, exceptfds;
	struct timeval timeout;
	while(1) {
		FD_ZERO(&readfds);
		FD_ZERO(&writefds);
		FD_ZERO(&exceptfds);
		FD_SET(dnsfd, &readfds);
		FD_SET(dnsfd, &exceptfds);
		timeout.tv_sec = 5;
		timeout.tv_usec = 0;
		fprintf(stderr, "selecting...\n");
		rc = select(dnsfd+1, &readfds, &writefds, &exceptfds, &timeout);
		if (rc > 0) {
			fprintf(stderr, "something...\n");
			if (FD_ISSET(dnsfd, &readfds)) {
				my_read();
				}
			else if (FD_ISSET(dnsfd, &exceptfds)) {
				fprintf(stderr, "Exception on DNS socket\n");
				exit(3);
				}
			}
		else if (rc < 0 && errno != EINTR) {
			perror("select()");
			exit(3);
			}
		}
	}
Пример #14
0
ssize_t readline (int fd, void *vptr, size_t maxlen)
{
	int n, rc;
	char c, *ptr;

	ptr = vptr;
	for (n=1; n<maxlen; n++)
	{
		if ( (rc = my_read(fd,&c)) == 1)
		{
			*ptr++ = c;
			if (c == '\n')
				break;	/* newline is stored, like fgets() */
		}
		else if (rc == 0)
		{
			if (n == 1)
				return 0; /* EOF, no data read */
			else
				break; /* EOF, some data was read */
		}
		else
			return -1; /* error, errno set by read() */
	}
	*ptr = 0; /* null terminate like fgets() */
	return n;
}
Пример #15
0
int main()
{
	char *line;
	char **cmd;
	uneditedLine = (char*)malloc(256 * sizeof(char));

	while (1)
	{
		my_setup();
		my_prompt();
		line = my_read();
		strcpy(uneditedLine, line);		

		if (line == 0) return 0;
		if (line[0] == '\0') 
		{
			free(line);
			continue;
		}

		cmd = my_parse(line);
		my_execute(cmd);
		my_clean(line, cmd);
	}

	free(uneditedLine);

	return 0;
}
Пример #16
0
/* Function to read a data from a file. If file_size not exceeds 4096 bytes then read only direct block */
int read_file(char *filePath)
{
	int i;
	int file_inode_index = get_inode(filePath, 0, strlen(filePath));
	//int file_inode_index = 2;
	inode * file_inode = &(inode_table_object->inode_index[file_inode_index]);
	int file_size = file_inode->size;

	char buff[4096];
	si_block * si_block_object ;
	si_block_object = (si_block *) buff;
	my_read(si_block_object, BS, file_inode->single_indirect_block_offset);
#ifdef DEBUG_BUILD
	printf("in read.c read_file: *** File_inode: %d  di_db_offset: %d  si_block_offset:%d  ***\n", file_inode_index, file_inode->direct_block_offset,file_inode->single_indirect_block_offset);

	printf("\n--------------------------------------\n");
	for(i = 0;i < (BS / sizeof(int *));i++){
		printf("in read.c read_file(): si_block(%d) -> db_offset[%d]:%d\n",file_inode->single_indirect_block_offset,i,si_block_object->db_index[i]);
	}
	printf("\n--------------------------------------\n");
#endif
	if(file_size < sizeof(data_block))
		print_data_block(file_size, file_inode->direct_block_offset);
	else
		print_data_block(sizeof(data_block), file_inode->direct_block_offset);


	if(file_size > BS){
		//file_size -= BS;
		read_file_from_indirect_block(file_size-BS, file_inode);
	}
	//putc('\n',stdout);
	return 0;
}
Пример #17
0
static int system_raw_read(int f,int len,unsigned char *buf)
{
	
	if(my_read(f,buf,len) != len)
              return -1;
        return 0;
}
Пример #18
0
ssize_t readline(int fd, void *vptr, size_t maxlen)
{
    size_t n;
    ssize_t rc;
    char ch, *ptr;

    ptr = vptr;
    for(n=1; n<maxlen; n++) //last byte is terminate
    {
         rc  = my_read(fd, &ch);
         if( rc == 1 )
         {//read one char
            *ptr++ = ch;
            if(ch == '\n')
                break;
         }
         else if( rc == 0 )
         {
              *ptr = 0; //terminate
              return n-1;
         }
         else
             return -1;
    }

    *ptr = 0;
    return n;
}
Пример #19
0
ssize_t readline(int fd,void *vptr,size_t maxlen){

	ssize_t n,rc;
	char c,*ptr;
	ptr=vptr;

	for(n=1;n<maxlen;n++){
		if((rc=my_read(fd,&c))==1){
			*ptr++=c;
			if(c=='\n')
				break;


		}
	else if(rc==0){

		*ptr=0;
		return (n-1);

	}
	else
		return -1;

	}
	*ptr=0;
	return n;


	}
Пример #20
0
ssize_t
readline(int fd, void *vptr, size_t maxlen)
{

   int	n, rc;
   char	c, *ptr;

   ptr = vptr;
   for (n = 1; n < maxlen; n++) {
    	if ( (rc = my_read(fd, &c)) == 1) {  /* my_read è OK */
	   *ptr++ = c;
	   if (c == '\n')
	      break;	/* esce dal ciclo perchè ha letto il newline */
        } 
        else 
	   if (rc == 0) {	/* my_read ha letto l'EOF */
	      if (n == 1)
		 return(0);	/* esce e non ha letto nulla */
	      else
		 break;		/* esce solo dal ciclo perchè 
                                   ha letto qualcosa prima dell'EOF */
	   } 
           else			/* my_read è uscita per un errore */
	      return(-1);	/* termina; errno settato dalla read() */
   }

   *ptr = 0;	
   /* inserisce uno 0 per indicare la fine dell'input, coma la fgets() */
   return(n);                  /* restituisce il numero di byte letti */
}
Пример #21
0
// readline 线程安全版本
ssize_t readline(int fd, void *vptr, size_t maxlen)
{
    size_t  n, rc;
    char    c, *ptr;
    Rline   *tsd;

    if ((n = pthread_once(&rl_once, readline_once)) < 0) {
        errno = n;
        err_sys("pthread_once error");
    }
    if ((tsd = pthread_getspecific(rl_key)) == NULL) {
        tsd = (Rline *) calloc(1, sizeof(Rline));   // init to 0
        if ((n = pthread_setspecific(rl_key, tsd)) < 0) {
            errno = n;
            err_sys("pthread_setspecific error");
        }
    }

    ptr = vptr;
    for (n = 1; n < maxlen; n++) {
        if ((rc = my_read(tsd, fd, &c)) == 1) {
            *ptr++ = c;
            if (c == '\n') {
                break;
            }
        } else if (rc == 0) {
            *ptr = 0;
            return(n - 1);  // EOF, n -1 bytes read
        } else {
            return(-1);
        }
    }
    *ptr = 0;
    return(n);
}
Пример #22
0
int _nisam_cmp_static_record(register N_INFO *info, register const byte *old)
{
  DBUG_ENTER("_nisam_rectest");

  /* We are going to do changes; dont let anybody disturb */
  dont_break();				/* Dont allow SIGHUP or SIGINT */

  if (info->opt_flag & WRITE_CACHE_USED)
  {
    if (flush_io_cache(&info->rec_cache))
    {
      DBUG_RETURN(-1);
    }
    info->rec_cache.seek_not_done=1;		/* We have done a seek */
  }

  if ((info->opt_flag & READ_CHECK_USED))
  {						/* If check isn't disabled  */
    info->rec_cache.seek_not_done=1;		/* We have done a seek */
    VOID(my_seek(info->dfile,info->lastpos,MY_SEEK_SET,MYF(0)));
    if (my_read(info->dfile, (char*) info->rec_buff, info->s->base.reclength,
		MYF(MY_NABP)))
      DBUG_RETURN(-1);
    if (memcmp((byte*) info->rec_buff, (byte*) old,
	       (uint) info->s->base.reclength))
    {
      DBUG_DUMP("read",old,info->s->base.reclength);
      DBUG_DUMP("disk",info->rec_buff,info->s->base.reclength);
      my_errno=HA_ERR_RECORD_CHANGED;		/* Record have changed */
      DBUG_RETURN(1);
    }
  }
  DBUG_RETURN(0);
}
Пример #23
0
static
ssize_t
my_xb_crypt_read_callback(void *userdata, void *buf, size_t len)
{
	File* file = (File *) userdata;
	return my_read(*file, buf, len, MYF(MY_WME));
}
Пример #24
0
ssize_t
gf_readline (int fd, void *vptr, size_t maxlen)
{
        size_t       n   = 0;
        size_t       rc  = 0;
        char         c   = ' ';
        char        *ptr = NULL;
        read_line_t *tsd = NULL;

        if (gf_readline_init_once (&tsd))
                return -1;

        ptr = vptr;
        for (n = 1; n < maxlen; n++) {
                if ( (rc = my_read (tsd, fd, &c)) == 1 ) {
                        *ptr++ = c;
                        if (c == '\n')
                                break;
                } else if (rc == 0) {
                        *ptr = '\0';
                        return (n - 1);
                } else
                        return -1;
        }

        *ptr = '\0';
        return n;

}
Пример #25
0
ssize_t
readline_r(Rline *rptr)
{
    int		n, rc;
    char	c, *ptr;

    ptr = rptr->read_ptr;
    for (n = 1; n < rptr->read_maxlen; n++)
    {
        if ( (rc = my_read(rptr, &c)) == 1)
        {
            *ptr++ = c;
            if (c == '\n')
                break;
        }
        else if (rc == 0)
        {
            *ptr = 0;
            return(n - 1);	/* EOF, n - 1 bytes were read */
        }
        else
            return(-1);	/* error */
    }

    *ptr = 0;
    return(n);
}
Пример #26
0
void symdirget(char *dir)
{
  char buff[FN_REFLEN+1];
  char *pos=strend(dir);
  if (dir[0] && pos[-1] != FN_DEVCHAR && my_access(dir, F_OK))
  {
    File file;
    size_t length;
    char temp= *(--pos);            /* May be "/" or "\" */
    strmov(pos,".sym");
    file= my_open(dir, O_RDONLY, MYF(0));
    *pos++=temp; *pos=0;	  /* Restore old filename */
    if (file >= 0)
    {
      if ((length= my_read(file, buff, sizeof(buff) - 1, MYF(0))) > 0)
      {
	for (pos= buff + length ;
	     pos > buff && (iscntrl(pos[-1]) || isspace(pos[-1])) ;
	     pos --);

	/* Ensure that the symlink ends with the directory symbol */
	if (pos == buff || pos[-1] != FN_LIBCHAR)
	  *pos++=FN_LIBCHAR;

	strmake(dir,buff, (size_t) (pos-buff));
      }
      my_close(file, MYF(0));
    }
  }
}
Пример #27
0
int readline(int fd, void *vptr, size_t maxlen)
{
	int        n, rc;
	char c, *ptr;

	ptr = (char*)vptr;

	for (n = 1; n < maxlen; n++)
	{
		if ((rc = my_read(fd, &c)) == 1)
		{
			*ptr++ = c;

			if (c == '\n')
			{
				break; /* newline is stored, like fgets() */
			}
		}
		else if (rc == 0)
		{
			*ptr = 0;
			return(n - 1); /* EOF, n - 1 bytes were read */
		}
		else
		{
			return(-1);        /* error, errno set by read() */
		}
	}

	*ptr = 0; /* null terminate like fgets() */
	return(n);
}
Пример #28
0
int main()
{
    struct sockaddr_in sin;
    struct sockaddr_in cin;
    int l_fd;
    int c_fd;
    socklen_t len;
    char buf[MAX_LINE];
    char addr_p[INET_ADDRSTRLEN];
    int port = 8000;
    int n;
    bzero(&sin, sizeof(sin));
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = INADDR_ANY;
    sin.sin_port = htons(port);
    if ( (l_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        perror("fail to create socket");
        exit(1);
    }
    if (bind(l_fd, (struct sockaddr *)&sin, sizeof(sin)) == -1) {
        perror("fail to bind");
        exit(1);
    }
    if (listen(l_fd, 10) == -1) {
        perror("fail to listen");
        exit(1);
    }
    printf("waiting ...\n");
    while (1)
    {
        if ((c_fd = accept(l_fd, (struct sockaddr *)&cin, &len)) == -1) {
            perror("fail to accept");
            exit(1);
        }
        n = my_read(c_fd, buf, MAX_LINE);
        if (n == -1) {
            exit(1);
        } else if (n == 0) {
            printf("the connect has been closed\n");
            close(c_fd);
            continue;
        }
        inet_ntop(AF_INET, &cin.sin_addr, addr_p, sizeof(addr_p));
        printf("client IP is %s, port is %d\n", addr_p, ntohs(cin.sin_port));
        printf("contens is : %s\n", buf);
        my_fun(buf);
        n = write(c_fd, buf, n);
        if (n == -1) {
            exit(1);
        }

        if (close(c_fd) == -1) {
            perror("fail to close");
            exit(1);
        }
    }

    return 0;
}
Пример #29
0
unsigned BatchChdir( const char *new_dir )
{
    buff[0] = LNK_CWD;
    strcpy( &buff[1], new_dir );
    my_write( pipeHdl, buff, strlen( buff ) + 1 );
    my_read( pipeHdl, buff, sizeof( buff ) );
    return( *(unsigned long *)&buff[1] );
}
Пример #30
0
byte DiskRead(byte ID,byte *Buf,int N)
{
  if (DiskPresent(ID)) {
    if(my_lseek(ID,N*512L,0)==N*512L)
      return(my_read(ID,Buf,512)==512);
  }
  return(0);
}