コード例 #1
0
ファイル: scamper_fds.c プロジェクト: shinglee/test
/*
 * scamper_fd_private
 *
 * allocate a private fd for scamper to manage.  this fd is not shared amongst
 * scamper.
 */
scamper_fd_t *scamper_fd_private(int fd,
				 scamper_fd_cb_t read_cb, void *read_param,
				 scamper_fd_cb_t write_cb, void *write_param)
{
  scamper_fd_t *fdn = NULL;

  if((fdn = fd_alloc(SCAMPER_FD_TYPE_PRIVATE, fd)) == NULL)
    {
      goto err;
    }

  if((fdn->fd_list_node = dlist_tail_push(fd_list, fdn)) == NULL)
    goto err;

  if(read_cb != NULL)
    {
      scamper_fd_read_set(fdn, read_cb, read_param);
      scamper_fd_read_unpause(fdn);
    }

  if(write_cb != NULL)
    {
      scamper_fd_write_set(fdn, write_cb, write_param);
      scamper_fd_write_unpause(fdn);
    }

  return fdn;

 err:
  if(fdn != NULL) fd_free(fdn);
  return NULL;
}
コード例 #2
0
ファイル: fileio.c プロジェクト: ChunHungLiu/bos
/*
 * open a file with flags and mode and return file descriptor.
 */
int open(const char * path, u32_t flags, u32_t mode)
{
    char buf[MAX_PATH];
    struct file * fp;
    int fd;
    int err;

    if((fd = fd_alloc(0)) < 0)
        return -1;

    if(vfs_path_conv(path, buf) !=0 )
    {
        fd_free(fd);
        return -1;
    }

    if((err = sys_open(buf, flags, mode, &fp)) != 0)
    {
        fd_free(fd);
        return err;
    }

    set_fp(fd, fp);
    return fd;
}
コード例 #3
0
ファイル: file.c プロジェクト: amitarya/junk
// Open a file (or directory).
//
// Returns:
// 	The file descriptor index on success
// 	-E_BAD_PATH if the path is too long (>= MAXPATHLEN)
// 	< 0 for other errors.
int
open(const char *path, int mode)
{
	// Find an unused file descriptor page using fd_alloc.
	// Then send a file-open request to the file server.
	// Include 'path' and 'omode' in request,
	// and map the returned file descriptor page
	// at the appropriate fd address.
	// FSREQ_OPEN returns 0 on success, < 0 on failure.
	//
	// (fd_alloc does not allocate a page, it just returns an
	// unused fd address.  Do you need to allocate a page?)
	//
	// Return the file descriptor index.
	// If any step after fd_alloc fails, use fd_close to free the
	// file descriptor.

	// LAB 5: Your code here.
	struct Fd *fd;
	int r;

	if((r = fd_alloc(&fd)) < 0)
		return r;
	strcpy(fsipcbuf.open.req_path, path);
        fsipcbuf.open.req_omode = mode;
        ipc_send(envs[1].env_id, FSREQ_OPEN, &fsipcbuf, PTE_P | PTE_W | PTE_U);
        if((r = ipc_recv(NULL, fd, NULL))<0)
		return r;
	return fd2num(fd);
	panic("open not implemented");
}
コード例 #4
0
ファイル: file.c プロジェクト: ren85/jos2006
// Open a file (or directory),
// returning the file descriptor index on success, < 0 on failure.
int
open(const char *path, int mode)
{
	// Find an unused file descriptor page using fd_alloc.
	// Then send a message to the file server to open a file
	// using a function in fsipc.c.
	// (fd_alloc does not allocate a page, it just returns an
	// unused fd address.  Do you need to allocate a page?  Look
	// at fsipc.c if you aren't sure.)
	// Then map the file data (you may find fmap() helpful).
	// Return the file descriptor index.
	// If any step fails, use fd_close to free the file descriptor.

	// LAB 5: Your code here.
	
	int r;
	struct Fd *fd;

	if ((r = fd_alloc(&fd)) < 0)
		return r;
	
	if ((r = fsipc_open(path, mode, fd)) < 0){
		fd_close(fd, 0);	
		return r;
	}

	if ((r = fmap(fd, 0, fd->fd_file.file.f_size) ) < 0){
		fd_close(fd, 0);	
		return r;
	}	
	
	return fd2num(fd);
}
コード例 #5
0
// Open a file (or directory).
//
// Returns:
// 	The file descriptor index on success
// 	-E_BAD_PATH if the path is too long (>= MAXPATHLEN)
// 	< 0 for other errors.
int
open(const char *path, int mode)
{
	// Find an unused file descriptor page using fd_alloc.
	// Then send a file-open request to the file server.
	// Include 'path' and 'omode' in request,
	// and map the returned file descriptor page
	// at the appropriate fd address.
	// FSREQ_OPEN returns 0 on success, < 0 on failure.
	//
	// (fd_alloc does not allocate a page, it just returns an
	// unused fd address.  Do you need to allocate a page?)
	//
	// Return the file descriptor index.
	// If any step after fd_alloc fails, use fd_close to free the
	// file descriptor.

	// LAB 5: Your code here.

	struct Fd* retval;
	int r = fd_alloc(&retval);
	if(r<0) return r;

	fsipcbuf.open.req_omode = mode;
	strcpy(fsipcbuf.open.req_path, path);
	r = fsipc(FSREQ_OPEN, retval);
	if (r<0) {
		fd_close(retval, 0);
		return r;	
	}
	return fd2num(retval);

	// panic("open not implemented");
}
コード例 #6
0
ファイル: file.c プロジェクト: AlexandrSalin/JOS
// Open a file (or directory).
//
// Returns:
// 	The file descriptor index on success
// 	-E_BAD_PATH if the path is too long (>= MAXPATHLEN)
// 	< 0 for other errors.
int
open(const char *path, int mode)
{
	// Find an unused file descriptor page using fd_alloc.
	// Then send a file-open request to the file server.
	// Include 'path' and 'omode' in request,
	// and map the returned file descriptor page
	// at the appropriate fd address.
	// FSREQ_OPEN returns 0 on success, < 0 on failure.
	//
	// (fd_alloc does not allocate a page, it just returns an
	// unused fd address.  Do you need to allocate a page?)
	//
	// Return the file descriptor index.
	// If any step after fd_alloc fails, use fd_close to free the
    struct Fd *f    = NULL;
    int r   = 0;

    if (!path)
        return -E_INVAL;

    if((r=fd_alloc(&f))<0)
        return r;

	strcpy(fsipcbuf.open.req_path, path);
	fsipcbuf.open.req_omode = mode;

    if ((r=fsipc(FSREQ_OPEN, f))<0) {
        fd_close(f, 0);
        return r;
    }
    return fd2num(f);
}
コード例 #7
0
ファイル: accept.c プロジェクト: dzavalishin/oskit
int
accept(int fd, struct sockaddr *addr, int *anamelen)
{
	oskit_error_t	rc;
	oskit_socket_t	*newsock;
	int		newfd;

	if (fd_check_socket(fd))
		return -1;
	fd_access_lock(fd, FD_RDWR);

	/* Accept a new connection */
        rc = oskit_socket_accept(fd_array[fd].socket, 
		(struct oskit_sockaddr *)addr, anamelen, &newsock);
	
	fd_access_unlock(fd, FD_RDWR);
        if (rc) {
		errno = rc;
		return -1;
	}

	/* Allocate a file descriptor for it */
	newfd = fd_alloc((oskit_iunknown_t*)newsock, 0);
	if (newfd < 0) {
		oskit_socket_release(newsock);
		return -1;
	}
	fd_lock(newfd);
	fd_array[newfd].socket = newsock;
	fd_unlock(newfd);

        return newfd;
}
コード例 #8
0
ファイル: pipe.c プロジェクト: BGCX262/zt-jos-svn-to-git
int
pipe(int pfd[2])
{
	int r;
	struct Fd *fd0, *fd1;
	void *va;

	// allocate the file descriptor table entries
	if ((r = fd_alloc(&fd0)) < 0
	    || (r = sys_page_alloc(0, fd0, PTE_P|PTE_W|PTE_U|PTE_SHARE)) < 0)
		goto err;

	if ((r = fd_alloc(&fd1)) < 0
	    || (r = sys_page_alloc(0, fd1, PTE_P|PTE_W|PTE_U|PTE_SHARE)) < 0)
		goto err1;

	// allocate the pipe structure as first data page in both
	va = fd2data(fd0);
	if ((r = sys_page_alloc(0, va, PTE_P|PTE_W|PTE_U|PTE_SHARE)) < 0)
		goto err2;
	if ((r = sys_page_map(0, va, 0, fd2data(fd1), PTE_P|PTE_W|PTE_U|PTE_SHARE)) < 0)
		goto err3;

	// set up fd structures
	fd0->fd_dev_id = devpipe.dev_id;
	fd0->fd_omode = O_RDONLY;

	fd1->fd_dev_id = devpipe.dev_id;
	fd1->fd_omode = O_WRONLY;

	if (debug)
		cprintf("[%08x] pipecreate %08x\n", env->env_id, vpt[VPN(va)]);

	pfd[0] = fd2num(fd0);
	pfd[1] = fd2num(fd1);
	return 0;

    err3:
	sys_page_unmap(0, va);
    err2:
	sys_page_unmap(0, fd1);
    err1:
	sys_page_unmap(0, fd0);
    err:
	return r;
}
コード例 #9
0
ファイル: scamper_fds.c プロジェクト: shinglee/test
scamper_fd_t *scamper_fd_dl(int ifindex)
{
  scamper_fd_t *fdn = NULL, findme;
  int fd = -1;

  findme.type = SCAMPER_FD_TYPE_DL;
  findme.fd_dl_ifindex = ifindex;

  if((fdn = fd_find(&findme)) != NULL)
    {
      scamper_fd_read_unpause(fdn);
      return fdn;
    }

  /*
   * open the file descriptor for the ifindex, and then allocate a scamper_fd
   * for the file descriptor
   */
  if((fd  = scamper_dl_open(ifindex)) == -1 ||
     (fdn = fd_alloc(SCAMPER_FD_TYPE_DL, fd)) == NULL)
    {
      goto err;
    }

  /*
   * record the ifindex for the file descriptor, and then allocate the state
   * that is maintained with it
   */
  fdn->fd_dl_ifindex = ifindex;

  /*
   * 1. add the file descriptor to the splay tree
   * 2. allocate state for the datalink file descriptor
   */
  if((fdn->fd_tree_node = splaytree_insert(fd_tree, fdn)) == NULL ||
     (fdn->fd_list_node = dlist_tail_push(fd_list, fdn)) == NULL ||
     (fdn->fd_dl_dl = scamper_dl_state_alloc(fdn)) == NULL)
    {
      goto err;
    }

  /* set the file descriptor up for reading */
  fdn->read.cb     = scamper_dl_read_cb;
  fdn->read.param  = fdn->fd_dl_dl;
  fdn->write.cb    = NULL;
  fdn->write.param = NULL;
  scamper_fd_read_unpause(fdn);

  return fdn;

 err:
  if(fdn != NULL) free(fdn);
  if(fd != -1) scamper_dl_close(fd);
  return NULL;
}
コード例 #10
0
ファイル: scamper_fds.c プロジェクト: shinglee/test
static scamper_fd_t *fd_tcp(int type, void *addr, uint16_t sport)
{
  scamper_fd_t *fdn, findme;
  size_t len = 0;
  int fd = -1;

  findme.type = type;
  findme.fd_tcp_addr = addr;
  findme.fd_tcp_sport = sport;

  if((fdn = fd_find(&findme)) != NULL)
    {
      return fdn;
    }

  if(type == SCAMPER_FD_TYPE_TCP4)
    {
      fd  = scamper_tcp4_open(addr, sport);
      len = sizeof(struct in_addr);
    }
  else if(type == SCAMPER_FD_TYPE_TCP6)
    {
      fd = scamper_tcp6_open(addr, sport);
      len = sizeof(struct in6_addr);
    }

  if(fd == -1 || (fdn = fd_alloc(type, fd)) == NULL ||
     (addr != NULL && (fdn->fd_tcp_addr = memdup(addr, len)) == NULL))
    {
      goto err;
    }
  fdn->fd_tcp_sport = sport;

  if((fdn->fd_tree_node = splaytree_insert(fd_tree, fdn)) == NULL ||
     (fdn->fd_list_node = dlist_tail_push(fd_list, fdn)) == NULL)
    {
      goto err;
    }

  return fdn;

 err:
  if(fd != -1)
    {
      if(type == SCAMPER_FD_TYPE_TCP4)
	scamper_tcp4_close(fd);
      else if(type == SCAMPER_FD_TYPE_TCP6)
	scamper_tcp6_close(fd);
    }
  if(fdn != NULL) fd_free(fdn);
  return NULL;
}
コード例 #11
0
ファイル: console.c プロジェクト: LancelotGT/JOS
int
opencons(void)
{
  int r;
  struct Fd* fd;

  if ((r = fd_alloc(&fd)) < 0)
    return r;
  if ((r = sys_page_alloc(0, fd, PTE_P|PTE_U|PTE_W|PTE_SHARE)) < 0)
    return r;
  fd->fd_dev_id = devcons.dev_id;
  fd->fd_omode = O_RDWR;
  return fd2num(fd);
}
コード例 #12
0
ファイル: file.c プロジェクト: h4xxel/trollos
int fd_open(int uid, const char *path, uint32_t flags) {
	int fd;

	if ((fd = fd_alloc()) < 0)
		return fd;
	//if ((vfs_file_descriptor[fd].ino = _path_to_inode(0, path)) < 0)
	//	goto fail;
	//vfs_file_descriptor[fd].pos = 0;
	//vfs_file_descriptor[fd].

fail:
	fd_return(fd);
	return -ENOENT;
}
コード例 #13
0
ファイル: console.c プロジェクト: ostest123/lab4gxemul
int
opencons(void)
{
	int r;
	struct Fd *fd;

	if ((r = fd_alloc(&fd)) < 0)
		return r;
	if ((r = syscall_mem_alloc(0, (u_int)fd, PTE_V|PTE_R|PTE_LIBRARY)) < 0)
		return r;
	fd->fd_dev_id = devcons.dev_id;
	fd->fd_omode = O_RDWR;
	return fd2num(fd);
}
コード例 #14
0
ファイル: sys.c プロジェクト: chobits/tinyos
int sys_open(char *name, unsigned int mode)
{
	struct file *file;
	int fd = fd_alloc();
	if (fd < 0)
		goto out;
	file = file_open(name, mode);
	if (!file)
		goto out_free_fd;
	fd_save_file(fd, file);
	return fd;
out_free_fd:
	fd_free(fd);
out:
	return -1;
}
コード例 #15
0
ファイル: sys.c プロジェクト: chobits/tinyos
int sys_mkdir(char *path, unsigned int mode)
{
	struct file *file;
	int fd = fd_alloc();
	if (fd < 0)
		goto out;
	file = file_mkdir(path, mode);
	if (!file)
		goto out_free_fd;
	fd_save_file(fd, file);
	return fd;
out_free_fd:
	fd_free(fd);
out:
	return -1;
}
コード例 #16
0
    void
host_ipc_init()
{
    int r;
    if ((r = fd_alloc(&host_fd)) < 0)
        panic("Couldn't allocate an fd!");

    strcpy(host_fsipcbuf.open.req_path, HOST_FS_FILE);
    host_fsipcbuf.open.req_omode = O_RDWR;

    if ((r = host_fsipc(FSREQ_OPEN, host_fd)) < 0) {
        fd_close(host_fd, 0);
        panic("Couldn't open host file!");
    }

}
コード例 #17
0
ファイル: file.c プロジェクト: PennPanda/mitjos
// Open a file (or directory).
//
// Returns:
// 	The file descriptor index on success
// 	-E_BAD_PATH if the path is too long (>= MAXPATHLEN)
// 	< 0 for other errors.
int
open(const char *path, int mode)
{
	// Find an unused file descriptor page using fd_alloc.
	// Then send a file-open request to the file server.
	// Include 'path' and 'omode' in request,
	// and map the returned file descriptor page
	// at the appropriate fd address.
	// FSREQ_OPEN returns 0 on success, < 0 on failure.
	//
	// (fd_alloc does not allocate a page, it just returns an
	// unused fd address.  Do you need to allocate a page?)
	//
	// Return the file descriptor index.
	// If any step after fd_alloc fails, use fd_close to free the
	// file descriptor.

	// LAB 5: Your code here.
	//panic("open not implemented");
	int result;
	struct Fd *fd_instance;
	
	if(strlen(path) >= MAXPATHLEN)
	{
		cprintf("open() error: path is too long");
		return -E_BAD_PATH;
	}
	
	if((result=fd_alloc(&fd_instance)) < 0)
	{
		return result;
	}
	
	strcpy(fsipcbuf.open.req_path, path);
	fsipcbuf.open.req_omode=mode;
	
	if((result=fsipc(FSREQ_OPEN, (void *)fd_instance)) < 0) 
	{
		fd_close(fd_instance, 0);
		
		return result;
	}
	else
	{		
		return fd2num(fd_instance);
	}
}
コード例 #18
0
ファイル: vmx_host.c プロジェクト: HeidCloud/Hypervisor
    void
host_ipc_init()
{
    int r;
    if ((r = fd_alloc(&host_fd)) < 0)
    //if(( host_fd = (struct Fd*)malloc(sizeof(host_fd)))< 0)
     if((r = sys_page_alloc(0, (void*)host_fd, PTE_P|PTE_W|PTE_U)) < 0)
		panic("Couldn't allocate an fd!");

    strcpy(host_fsipcbuf.open.req_path, HOST_FS_FILE);
    host_fsipcbuf.open.req_omode = O_RDWR;

    if ((r = host_fsipc(FSREQ_OPEN, host_fd)) < 0) {
        fd_close(host_fd, 0);
        panic("Couldn't open host file!");
    }

}
コード例 #19
0
ファイル: epoll.c プロジェクト: fengye0316/rtos-3
int _epoll_create(int ignored)
{
	int i, fd;
	struct epoll_file *ef = NULL;
	struct file *f = NULL;

	/* find epoll_file struct */
	for(i = 0; i < EPOLL_MAXFDS; i++) {
		if(!files[i].file) {
			ef = &files[i];
			break;
		}
	}
	if(!ef) {
		errno = ENOMEM;
		return -1;
	}

	/* allocate file struct */
	f = file_alloc();
	if(!f) {
		errno = ENOMEM;
		return -1;
	}

	/* allocate fd */
	fd = fd_alloc(f);
	if(fd == -1) {
		file_close(f);
		errno = EMFILE;
		return -1;
	}

	/* got everything, fill out structures */
	f->f_ops = &epoll_operations;
	f->f_cookie_ptr = (void *)ef;
	ef->file = f;
	for(i = 0; i < EPOLL_MAXFDS; i++) {
		ef->entries[i].fd = -1;
	}

	/* return fd */
	return fd;
}
コード例 #20
0
    void
host_ipc_init()
{
    int r;
    if ((r = fd_alloc(&host_fd)) < 0)
        panic("Couldn't allocate an fd!");
    
    //r = sys_page_alloc(0, &host_fd, PTE_P | PTE_U | PTE_W);
    //if (r < 0)
    //{
    //    panic("Not Valid ALloc");
    //}
    strcpy(host_fsipcbuf.open.req_path, HOST_FS_FILE);
    host_fsipcbuf.open.req_omode = O_RDWR;

    if ((r = host_fsipc(FSREQ_OPEN, host_fd)) < 0) {
        fd_close(host_fd, 0);
        panic("Couldn't open host file!");
    }

}
コード例 #21
0
ファイル: file.c プロジェクト: ledinhminh/jos
// Open a file (or directory).
//
// Returns:
// 	The file descriptor index on success
// 	-E_BAD_PATH if the path is too long (>= MAXPATHLEN)
// 	< 0 for other errors.
int
open(const char *path, int mode)
{
	// Find an unused file descriptor page using fd_alloc.
	// Then send a file-open request to the file server.
	// Include 'path' and 'omode' in request,
	// and map the returned file descriptor page
	// at the appropriate fd address.
	// FSREQ_OPEN returns 0 on success, < 0 on failure.
	//
	// (fd_alloc does not allocate a page, it just returns an
	// unused fd address.  Do you need to allocate a page?)
	//
	// Return the file descriptor index.
	// If any step after fd_alloc fails, use fd_close to free the
	// file descriptor.

	// LAB 5: Your code here.
  int r;
  struct Fd *fd;

  r = fd_alloc(&fd);
  if (r < 0) return r;

        // DO NOT ALLOCATE !!
        //r = sys_page_alloc(0, fd, PTE_U|PTE_W|PTE_P);
        //if (r < 0) goto out;

  if (strlen(path) >= MAXPATHLEN)
    return -E_BAD_PATH;
  strcpy(fsipcbuf.open.req_path, path);
  fsipcbuf.open.req_omode = mode;
  r = fsipc(FSREQ_OPEN, fd);
  if (r < 0) goto out;
  return fd2num(fd);
out:
  assert(fd_close(fd, 0) == 0);
  return r;
}
コード例 #22
0
ファイル: scamper_fds.c プロジェクト: shinglee/test
static scamper_fd_t *fd_null(int type)
{
  scamper_fd_t *fdn = NULL, findme;
  int fd = -1;

  /* first check if a sharable fd exists for this type */
  findme.type = type;
  if((fdn = fd_find(&findme)) != NULL)
    {
      return fdn;
    }

  if(type == SCAMPER_FD_TYPE_RTSOCK) fd = scamper_rtsock_open();
  else if(type == SCAMPER_FD_TYPE_IFSOCK) fd = socket(AF_INET, SOCK_DGRAM, 0);
  else if(type == SCAMPER_FD_TYPE_IP4) fd = scamper_ip4_openraw();

  if(fd == -1 || (fdn = fd_alloc(type, fd)) == NULL ||
     (fdn->fd_tree_node = splaytree_insert(fd_tree, fdn)) == NULL ||
     (fdn->fd_list_node = dlist_tail_push(fd_list, fdn)) == NULL)
    {
      goto err;
    }

  return fdn;

 err:
  if(fd != -1)
    {
      if(type == SCAMPER_FD_TYPE_RTSOCK)
	scamper_rtsock_close(fd);
      else if(type == SCAMPER_FD_TYPE_IFSOCK)
	close(fd);
      else if(type == SCAMPER_FD_TYPE_IP4)
	scamper_ip4_close(fd);
    }
  if(fdn != NULL) fd_free(fdn);
  return NULL;
}
コード例 #23
0
// Open a file (or directory).
//
// Returns:
// 	The file descriptor index on success
// 	-E_BAD_PATH if the path is too long (>= MAXPATHLEN)
// 	< 0 for other errors.
int
open(const char *path, int mode)
{
	// Find an unused file descriptor page using fd_alloc.
	// Then send a file-open request to the file server.
	// Include 'path' and 'omode' in request,
	// and map the returned file descriptor page
	// at the appropriate fd address.
	// FSREQ_OPEN returns 0 on success, < 0 on failure.
	//
	// (fd_alloc does not allocate a page, it just returns an
	// unused fd address.  Do you need to allocate a page?)
	//
	// Return the file descriptor index.
	// If any step after fd_alloc fails, use fd_close to free the
	// file descriptor.

	if (strlen(path) > MAXPATHLEN)
		return -E_BAD_PATH;

	struct Fd *fd;
	int r;
	if ((r < fd_alloc(&fd)) < 0)
		return r;

        strcpy(fsipcbuf.open.req_path, path);
        fsipcbuf.open.req_omode = mode;

        if ((r = fsipc(FSREQ_OPEN, fd)) < 0) {
		fd_close(fd, 0);
                return r;
	}

	return fd2num(fd);

	panic("open not implemented");
}
コード例 #24
0
ファイル: fileio.c プロジェクト: ChunHungLiu/bos
/*
 * open a directory
 */
void * opendir(const char * name)
{
    char buf[MAX_PATH];
    struct dir * dir;
    struct file * fp;
    int fd;
    int err;

    if((dir = malloc(sizeof(struct dir))) == NULL)
        return NULL;

    /* find empty slot for file descriptor. */
    if((fd = fd_alloc(0)) < 0)
    {
        free(dir);
        return NULL;
    }

    if((err = vfs_path_conv(name, buf)) !=0 )
    {
        free(dir);
        fd_free(fd);
        return NULL;
    }

    if((err = sys_opendir(buf, &fp)) != 0)
    {
        free(dir);
        fd_free(fd);
        return NULL;
    }

    set_fp(fd, fp);
    dir->fd = fd;

    return (void *)dir;
}
コード例 #25
0
ファイル: server.c プロジェクト: semerdjiev/Event-server
int
main (int argc, char *argv[])
{
  int cl_sfd,adm_sfd, s,u;
  int efd;
  char small_buf[10];
  struct epoll_event event;
   struct epoll_event event2;
  struct epoll_event *events;
  struct ev_conn *tmpptr=NULL;
  struct rlimit limit;
  long maxfd = MAX_FD;
  //allocate and check memory
  
  
  
      limit.rlim_cur = maxfd;
	  limit.rlim_max = maxfd;
      if ( setrlimit( RLIMIT_NOFILE, &limit ) == -1 ) {
	perror( "unable to set new soft limit" );
	return 1;
      }
    
  /* obtain hard/soft limit */
  if ( getrlimit( RLIMIT_NOFILE, &limit ) == -1 ) {
    perror( "unable to obtain limits" );
    return 1;
  } else {
    printf( "FD limit = { hard : %d, soft : %d }\n",
	    limit.rlim_max, limit.rlim_cur );
  }
  
  ev_conn_ptr=(struct ev_conn *) malloc(sizeof(struct ev_conn)*MAX_CLIENTS);
  if (ev_conn_ptr == NULL) {
		fprintf(stderr,"malloc can't allocate memory !!!");
		return 0;
	}
  //

 //bind on the client port
	fprintf(stderr,"Binding on the client port...\n");
  cl_sfd = create_and_bind (CLIENT_PORT);
  if (cl_sfd == -1)
    abort();

  s = make_socket_non_blocking (cl_sfd);
  if (s == -1)
    abort();

  s = listen (cl_sfd, SOMAXCONN);
  if (s == -1)
    {
      perror ("listen");
      abort();
    }

  efd = epoll_create1 (0);
  if (efd == -1)
    {
      perror ("epoll_create");
      abort();
    }
fprintf(stderr,"Client sfd %d\n",cl_sfd);
  event.data.ptr =  fd_alloc(cl_sfd);;
//  event.data.u64 = 0;
//  event.data.u32 = 0;
  event.events = EPOLLIN | EPOLLET;
  s = epoll_ctl (efd, EPOLL_CTL_ADD, cl_sfd, &event);
  if (s == -1)
    {
      perror ("epoll_ctl");
      abort();
    }
	
 //bind on the admin port
	fprintf(stderr,"Binding on the admin port...\n");
  adm_sfd = create_and_bind (ADMIN_PORT);
  if (adm_sfd == -1)
    abort();

  s = make_socket_non_blocking (adm_sfd);
  if (s == -1)
    abort();

  s = listen (adm_sfd, SOMAXCONN);
  if (s == -1)
    {
      perror ("listen");
      abort();
    }

fprintf(stderr,"Admin sfd %d\n",adm_sfd);
  event2.data.ptr = fd_alloc(adm_sfd);
//  event2.data.u64 = 0;
//  event2.data.u32 = 0;
  event2.events = EPOLLIN | EPOLLET;
  s = epoll_ctl (efd, EPOLL_CTL_ADD, adm_sfd, &event2);
  if (s == -1)
    {
      perror ("epoll_ctl");
      abort();
    }

  /* Buffer where events are returned */
  events = calloc (MAXEVENTS, sizeof event);

  /* The event loop */
  while (1)
    {
      int n, i;

      n = epoll_wait (efd, events, MAXEVENTS, -1);
	  
      for (i = 0; i < n; i++)
	{
	struct fd *tmpfd=events[i].data.ptr;
		fprintf(stderr,"wait stopped with %d events fd %d\n",n,tmpfd->sock);
		//continue;
	  if ((events[i].events & EPOLLERR) ||
              (events[i].events & EPOLLHUP) ||
              (!(events[i].events & EPOLLIN)))
	    {
              /* An error has occured on this fd, or the socket is not
                 ready for reading (why were we notified then?) */
	      fprintf (stderr, "epoll error closing the socket or not error maybe\n");
			
	      fd_close(tmpfd);
	      continue;
	    }
	
	  else if (adm_sfd == tmpfd->sock)
	    {
			fprintf(stderr,"admin connection\n");
              /* We have a notification on the listening socket, which
                 means one or more incoming connections. */
              while (1)
                {
			      struct fd *allocfd=NULL;
                  struct sockaddr in_addr;
                  socklen_t in_len;
                  int infd;
                  char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];

                  in_len = sizeof in_addr;
                  infd = accept (adm_sfd, &in_addr, &in_len);
                  if (infd == -1)
                    {
                      if ((errno == EAGAIN) ||
                          (errno == EWOULDBLOCK))
                        {
                          /* We have processed all incoming
                             connections. */
                          break;
                        }
                      else
                        {
                          perror ("accept");
                          break;
                        }
                    }
					
				//TODO da comentiram dolniq zapis, poneje e izlishen ama sega za debug 6te go ostavq
                  s = getnameinfo (&in_addr, in_len,
                                   hbuf, sizeof hbuf,
                                   sbuf, sizeof sbuf,
                                   NI_NUMERICHOST | NI_NUMERICSERV);
                  if (s == 0)
                    {
                      printf("Accepted Admin connection on descriptor %d "
                             "(host=%s, port=%s)\n", infd, hbuf, sbuf);
                    }

                  /* Make the incoming socket non-blocking and add it to the
                     list of fds to monitor. */
                  s = make_socket_non_blocking (infd);
                  if (s == -1)
                    abort();
					allocfd=fd_alloc(infd);
					allocfd->is_admin=1;
                  event.data.ptr = allocfd;
				  //event.data.u32 = 1;
                  event.events = EPOLLIN | EPOLLET;
                  s = epoll_ctl (efd, EPOLL_CTL_ADD, infd, &event);
                  if (s == -1)
                    {
                      perror ("epoll_ctl");
                      abort();
                    }
                }
              continue;
        }
		else if (cl_sfd == tmpfd->sock)
	    {
			fprintf(stderr,"client connection\n");
              /* We have a notification on the listening socket, which
                 means one or more incoming connections. */
              while (1)
                {
                  struct sockaddr in_addr;
                  socklen_t in_len;
                  int infd;
                  char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];

                  in_len = sizeof in_addr;
                  infd = accept (cl_sfd, &in_addr, &in_len);
                  if (infd == -1)
                    {
                      if ((errno == EAGAIN) ||
                          (errno == EWOULDBLOCK))
                        {
                          /* We have processed all incoming
                             connections. */
                          break;
                        }
                      else
                        {
                          perror ("accept");
                          break;
                        }
                    }
					//TODO da comentiram dolniq zapis, poneje e izlishen ama sega za debug 6te go ostavq
                  s = getnameinfo (&in_addr, in_len,
                                   hbuf, sizeof hbuf,
                                   sbuf, sizeof sbuf,
                                   NI_NUMERICHOST | NI_NUMERICSERV);
                  if (s == 0)
                    {
                      printf("Accepted Client connection on descriptor %d "
                             "(host=%s, port=%s)\n", infd, hbuf, sbuf);
                    }

                  /* Make the incoming socket non-blocking and add it to the
                     list of fds to monitor. */
                  s = make_socket_non_blocking (infd);
                  if (s == -1)
                    abort();

                  event.data.ptr = fd_alloc(infd);
                  event.events = EPOLLIN | EPOLLET;
                  s = epoll_ctl (efd, EPOLL_CTL_ADD, infd, &event);
                  if (s == -1)
                    {
                      perror ("epoll_ctl");
                      abort();
                    }
                }
              continue;
        }
        else
            {
              /* We have data on the fd waiting to be read. Read and
                 display it. We must read whatever data is available
                 completely, as we are running in edge-triggered mode
                 and won't get a notification again for the same
                 data. */
              int done = 0;
			fprintf(stderr,"check\n");
				if(tmpfd->is_admin)//admin socket
				{
				  ssize_t count=0;
				  int local_ptr=-1;
				  int buf_i=0;
				  if(tmpfd->buffer==NULL)
				  {
				  tmpfd->buffer=ev_buffer_alloc(BUFFER_SIZE);
				  tmpfd->buffer->len=0;
				  }
				  fprintf(stderr,"buffer ne e null\n");
				   char *buf=tmpfd->buffer->buf;
                  
				 while (1)
                {
					
					if(tmpfd->buffer->len>=BUFFER_SIZE)
						{
						fprintf(stderr,"max buffer size reached\n");
							done=1;
							break;
						}
                  count = read (tmpfd->sock, buf+tmpfd->buffer->len, (BUFFER_SIZE-tmpfd->buffer->len));
				  fprintf(stderr,"4ete ot admin\n");
				  write(0,buf+tmpfd->buffer->len,count);
                  if (count == -1)
                    {
                      /* If errno == EAGAIN, that means we have read all
                         data. So go back to the main loop. */
                      if (errno != EAGAIN)
                        {
                          perror ("read");
                          done = 1;
                        }
                      break;
                    }
                  else if (count == 0)
                    {
                      /* End of file. The remote has closed the
                         connection. */
                      done = 1;
                      break;
                    }
					tmpfd->buffer->len+=count;
				fprintf(stderr,"tmpfd->buffer->len e %d\n",tmpfd->buffer->len);
					
					

                  /* Write the buffer to standard output */
				 
				 if(tmpfd->cur_ptr<0)
				 {
				  if(buf[0]=='\n' || buf[0]=='\r') // new key
				  {
					u=0;
					while(u<ERROR_LOOP) //TODO to fix this da po4ne da 4isti socketite kogato sa na 80% pulni
					{
					fprintf(stderr,"vleze v cikula i vurti u\n");
						cur_ptr++;
						if(cur_ptr==MAX_CLIENTS)
						{
						cur_ptr=1;
						u++;
						}
						tmpptr=ev_conn_ptr+cur_ptr;
						if(!tmpptr->sock && tmpptr->buffer==NULL)
						{
						fprintf(stderr,"cur_ptr e %d\n",cur_ptr);
						sprintf(small_buf, "%d", cur_ptr); 
						//key generation
						fprintf(stderr,"small_buf e %s\n",small_buf);
						write(tmpfd->sock,small_buf,strlen(small_buf));
						fprintf(stderr,"brum2\n");
						//tmpfd->cur_ptr=cur_ptr;
						//adding the socket to the memory
						//tmpptr->sock=tmpfd->sock;
						
						break;
						}
						
					}
					if(u==ERROR_LOOP)
						{
						fprintf(stderr,"no free fds\n");
						write(tmpfd->sock,"ERROR",5);
						//TODO to send reconnect signals to the clients and to free the all fds
						abort();
						}
				  
						fprintf(stderr,"key %d\n",cur_ptr);
						done=1;
						break;
				  
				  }
				  else
				  {
				  fprintf(stderr,"chete admina kum koi client 6te se vurje\n");
				 
				 // write (0, buf, count);
				  
				  for(buf_i=0;buf_i<9 && *(buf+buf_i)!='\n' && *(buf+buf_i)!='\r';buf_i++)small_buf[buf_i]=*(buf+buf_i);
				  small_buf[buf_i]='\0';
				  local_ptr=strtol(small_buf, NULL, 10);
				  fprintf(stderr,"local_ptr se okaza %d\n",local_ptr);
				  tmpfd->buffer->offset=(buf_i+1);
					if(tmpfd->buffer->offset>tmpfd->buffer->len)
						{
							fprintf(stderr,"ERROR , the offset is bigger than the len.This should not happen\n");
							return -1;
						}
						
				 
				  if(!local_ptr || local_ptr>MAX_CLIENTS)
					{
					fprintf(stderr,"ERROR wrong number\n");
					write(tmpfd->sock,"ERROR",5);
					close(tmpfd->sock);
					tmpfd->sock=0;
					break;
					//error
					}
					tmpfd->cur_ptr=local_ptr;
					fprintf(stderr,"DEBUG count %d\n",count);
					fprintf(stderr,"DEBUG buf_i %d\n",buf_i);
				  }
				 }
				  
				  
  
				}
				
				if (done)
                {
				
				if((tmpfd->cur_ptr)>=0)
				{
					tmpptr=ev_conn_ptr+tmpfd->cur_ptr;
					//buf[count]='\0';//TODO tova da go vidq dali nqma da otreje posledniq symbol
				  if(tmpptr->sock)
				  {
				  fprintf(stderr,"ima clientski socket za %d i pi6e v nego\n",tmpfd->cur_ptr);
				  s = write (tmpptr->sock, tmpfd->buffer->buf+tmpfd->buffer->offset, tmpfd->buffer->len-tmpfd->buffer->offset);
				  s = write (0, tmpfd->buffer->buf+tmpfd->buffer->offset, tmpfd->buffer->len-tmpfd->buffer->offset);
                  if (s == -1)
                    {
                      perror ("write");
					  write(tmpfd->sock,"ERROR",5);
					  close(tmpfd->sock);
					  tmpfd->sock=0;
					  //nikov
					  if(tmpptr->sock){close(tmpptr->sock);tmpptr->sock=0;}
					  ev_buffer_free(tmpfd->buffer);
					  tmpfd->buffer=NULL;
					  break;
                    }
					
					//closing the client socket
					
					if(tmpptr->sock)close(tmpptr->sock);
					tmpptr->sock=0;
					ev_buffer_free(tmpfd->buffer);
					tmpfd->buffer=NULL;
					//if(tmpptr->buffer!=NULL)ev_buffer_free(tmpptr->buffer);
					
				   
				   }
				   else 
				   {
				   fprintf(stderr,"zapisva v buffer za %d golqm %d,\n",tmpfd->cur_ptr,tmpfd->buffer->len);
				   tmpptr->buffer=tmpfd->buffer;
				   
				   }
				   
				}
				 
                  printf ("Closed connection on descriptor %d\n",
                          tmpfd->sock);

                  /* Closing the descriptor will make epoll remove it
                     from the set of descriptors which are monitored. */
					 tmpfd->buffer=NULL;
                  close (tmpfd->sock);
                }
				
				}
				else // client socket
				{
				char buf[BUFFER_SIZE];
				  long int local_ptr=-1;
				  int buf_i=0;
				  int tmp=0;
				  int i=0;
				  int error=0;
				  ssize_t count;
					while (1)
					{
                  ssize_t count;
                  

                  count = read (tmpfd->sock, buf,BUFFER_SIZE);
				  fprintf(stderr,"client count %d\n",count);
                  if (count == -1)
                    {
                      /* If errno == EAGAIN, that means we have read all
                         data. So go back to the main loop. */
                      if (errno != EAGAIN)
                        {
                          perror ("read");
                          done = 1;
                        }
                      break;
                    }
                  else if (count == 0)
                    {
                      /* End of file. The remote has closed the
                         connection. */
                      done = 1;
                      break;
                    }
					
					if (strncmp(buf,"GET ",4))
							{
							break; 
							}
							
					for(i=0;i<count;i++)
					{
						fprintf(stderr,"%c %d\n",buf[i],i);
						if(buf[i]=='\r' || buf[i]=='\n')
						{
						break;
						}
					}
					if(i==count)
						{
							fprintf(stderr,"strange error in http protocol\n");
							fd_close(tmpfd);
							break;
						}
					fprintf(stderr,"i e %d\n",i);
					count=i;
					 
					if(count <5)
							{
							fprintf(stderr,"ERROR count out of boundaries\n");
							error=1;
							break;
							}
						
						
						
						fprintf(stderr,"buf+4 e %c\n",*(buf+4));
						buf_i=findend(buf+4,count);
						fprintf(stderr,"bif_i e %d\n",buf_i);
						buf[buf_i+4]='\0';
						tmp=buf_i;
						
						for(;buf[buf_i+4]!='/' && buf_i>0;buf_i--);
						if((tmp-(buf_i+1))>9)
							{
							fprintf(stderr,"ERROR count out of boundaries 2\n");
							
							error=1;
							break;
							}
						tmp=0;
						
						local_ptr = strtol(buf+4+buf_i+1, NULL, 10);
						fprintf(stderr,"local_ptr e %lld\n",local_ptr);
						if(local_ptr==0)
							{
							fprintf(stderr,"ERROR local_ptr is 0 for some reason\n");
							
							error=1;
							break;
								
							}
						if(local_ptr>MAX_CLIENTS)
						{
							fprintf(stderr,"ERROR local_ptr %ld",local_ptr);
							
							error=1;
							break;	
						}
						
						tmpptr=ev_conn_ptr+local_ptr;
						if(tmpptr->sock)
						{
							fprintf(stderr,"ERROR tmpptr->sock %d",tmpptr->sock);
							
							error=1;
							break;	
						}
						tmpptr->sock=tmpfd->sock;
						tmpfd->cur_ptr=local_ptr;
						done=1;
					}
					
					if(error)
					{
					s = write (tmpfd->sock, HEADER_BUSY, HEADER_LEN_BUSY);
					
					fd_close(tmpfd);tmpfd->sock=0;
					}
					else if (done && tmpfd->cur_ptr!=-1)
					{
					tmpptr=ev_conn_ptr+tmpfd->cur_ptr;
					s = write (tmpptr->sock, HEADER, HEADER_LEN);
					
						if(tmpptr->buffer!=NULL)
						{
						fprintf(stderr,"buffer ne e NULL len e %d\n",tmpptr->buffer->len);
						fprintf(stderr,"offset\n");
						fprintf(stderr,"buffer ne e NULL offset e %d\n",tmpptr->buffer->offset);
						//for(i=0;i<tmpptr->buffer->len;i++)fprintf(stderr,"%c %d\n",tmpptr->buffer->buf);
						s = write (tmpptr->sock, tmpptr->buffer->buf+tmpptr->buffer->offset, tmpptr->buffer->len-tmpptr->buffer->offset);
						write(0,tmpptr->buffer->buf+tmpptr->buffer->offset,tmpptr->buffer->len-tmpptr->buffer->offset);
						fprintf(stderr,"close\n");
						fd_close(tmpfd);
						tmpptr->sock=0;
						fprintf(stderr,"sock 0\n");
						ev_buffer_free(tmpptr->buffer);
						fprintf(stderr,"free\n");
						tmpptr->buffer=NULL;
						
						}
				
				
					}
					else if(done)
					{
					fprintf(stderr,"nqma cur_ptr i e done taka 4e zatvarq conneciqta\n");
					fd_close(tmpfd);tmpfd->sock=0;
					}
				
				
				}

              
            }
        }
    }

  free (events);

  close (adm_sfd);
  close (cl_sfd);


  return EXIT_SUCCESS;
}
コード例 #26
0
ファイル: scamper_fds.c プロジェクト: shinglee/test
static scamper_fd_t *fd_udp(int type, void *addr, uint16_t sport)
{
  scamper_fd_t *fdn, findme;
  size_t len = 0;
  int fd = -1;

  findme.type = type;
  findme.fd_udp_addr = addr;
  findme.fd_udp_sport = sport;

  if((fdn = fd_find(&findme)) != NULL)
    return fdn;

  if(type == SCAMPER_FD_TYPE_UDP4)
    {
      fd  = scamper_udp4_openraw(addr);
      len = sizeof(struct in_addr);
    }
  else if(type == SCAMPER_FD_TYPE_UDP6)
    {
      fd  = scamper_udp6_open(addr, sport);
      len = sizeof(struct in6_addr);
    }
  else if(type == SCAMPER_FD_TYPE_UDP4DG)
    {
      fd  = scamper_udp4_opendgram(addr, sport);
      len = sizeof(struct in_addr);
    }

  if(fd == -1 || (fdn = fd_alloc(type, fd)) == NULL ||
     (addr != NULL && (fdn->fd_udp_addr = memdup(addr, len)) == NULL))
    {
      printerror(errno, strerror, __func__, "could not open socket");
      goto err;
    }
  fdn->fd_udp_sport = sport;

  if((fdn->fd_tree_node = splaytree_insert(fd_tree, fdn)) == NULL)
    {
      printerror(errno, strerror, __func__, "could not add socket to tree");
      goto err;
    }
  if((fdn->fd_list_node = dlist_tail_push(fd_list, fdn)) == NULL)
    {
      printerror(errno, strerror, __func__, "could not add socket to list");
      goto err;
    }

  return fdn;

 err:
  if(fd != -1)
    {
      if(type == SCAMPER_FD_TYPE_UDP4 || type == SCAMPER_FD_TYPE_UDP4DG)
	scamper_udp4_close(fd);
      else if(type == SCAMPER_FD_TYPE_UDP6)
	scamper_udp6_close(fd);
    }
  if(fdn != NULL) fd_free(fdn);
  return NULL;
}