示例#1
0
文件: billingd.c 项目: selecli/squid
int billing_epoll_wait()
{
	int nfds;
	int i;
	int ret=0 ;

	nfds = epoll_wait(kdpfd, events, MAX_EVENTS, EPOLL_TIMEOUT);
	if(nfds == -1) {
		if( errno != EINTR ) {
			return -1;
		}

	} else if( 0 == nfds) {
		return 0;
	}


	for (i = 0; i < nfds; i++) {
		if (listen_fd == events[i].data.fd){
			handle_accept(listen_fd);
		}
		else if (events[i].events & EPOLLIN){
			read_billing_info(events[i].data.fd);
		}
		else if (events[i].events & (EPOLLHUP|EPOLLERR)){
			disconnect_fd(events[i].data.fd);
		}
	}
	return ret;
}
示例#2
0
/*
 * Ends use of the scanner.
 * 
 * From the SANE spec:
 * This function terminates the association between the device handle
 * passed in argument h and the device it represents. If the device is
 * presently active, a call to sane_cancel() is performed first. After
 * this function returns, handle h must not be used anymore.
 */
void
sane_close (SANE_Handle handle)
{
  DBG (10, "sane_close: start\n");

  sane_cancel(handle);
  disconnect_fd((struct scanner *) handle);

  DBG (10, "sane_close: finish\n");
}
示例#3
0
/*
 * Terminates the backend.
 * 
 * From the SANE spec:
 * This function must be called to terminate use of a backend. The
 * function will first close all device handles that still might be
 * open (it is recommended to close device handles explicitly through
 * a call to sane_close(), but backends are required to release all
 * resources upon a call to this function). After this function
 * returns, no function other than sane_init() may be called
 * (regardless of the status value returned by sane_exit(). Neglecting
 * to call this function may result in some resources not being
 * released properly.
 */
void
sane_exit (void)
{
  struct scanner *dev, *next;

  DBG (10, "sane_exit: start\n");

  for (dev = scanner_devList; dev; dev = next) {
      disconnect_fd(dev);
      next = dev->next;
      free (dev->device_name);
      free (dev);
  }

  if (sane_devArray)
    free (sane_devArray);

  scanner_devList = NULL;
  sane_devArray = NULL;

  DBG (10, "sane_exit: finish\n");
}
示例#4
0
/* callback used by sane_get_devices
 * build the scanner struct and link to global list 
 * unless struct is already loaded, then pretend 
 */
static SANE_Status
attach_one (const char *device_name)
{
    struct scanner *s;
    int ret, i;
    SANE_Word vid, pid;
  
    DBG (10, "attach_one: start '%s'\n", device_name);
  
    for (s = scanner_devList; s; s = s->next) {
        if (strcmp (s->sane.name, device_name) == 0) {
            DBG (10, "attach_one: already attached!\n");
            return SANE_STATUS_GOOD;
        }
    }
  
    /* build a scanner struct to hold it */
    DBG (15, "attach_one: init struct\n");
  
    if ((s = calloc (sizeof (*s), 1)) == NULL)
        return SANE_STATUS_NO_MEM;
  
    /* copy the device name */
    s->device_name = strdup (device_name);
    if (!s->device_name){
        free (s);
        return SANE_STATUS_NO_MEM;
    }
  
    /* connect the fd */
    DBG (15, "attach_one: connect fd\n");
  
    s->fd = -1;
    ret = connect_fd(s);
    if(ret != SANE_STATUS_GOOD){
        free (s->device_name);
        free (s);
        return ret;
    }
  
    /* clean up the scanner struct based on model */
    /* this is the only piece of model specific code */
    sanei_usb_get_vendor_product(s->fd,&vid,&pid);
  
    if(vid == 0x08f0){
        s->vendor_name = "CardScan";
        if(pid == 0x0005){
            s->product_name = "800c";
        }
        else if(pid == 0x0002){
            s->product_name = "600c";
        }
        else{
            DBG (5, "Unknown product, using default settings\n");
            s->product_name = "Unknown";
        }
    }
    else if(vid == 0x0451){
        s->vendor_name = "Sanford";
        if(pid == 0x6250){
            s->product_name = "800c";
        }
        else{
            DBG (5, "Unknown product, using default settings\n");
            s->product_name = "Unknown";
        }
    }
    else{
        DBG (5, "Unknown vendor/product, using default settings\n");
        s->vendor_name = "Unknown";
        s->product_name = "Unknown";
    }
  
    DBG (15, "attach_one: Found %s scanner %s at %s\n",
      s->vendor_name, s->product_name, s->device_name);
 
    /*copy config file settings*/
    s->has_cal_buffer = global_has_cal_buffer;
    s->lines_per_block = global_lines_per_block;
    s->color_block_size = s->lines_per_block * PIXELS_PER_LINE * 3;
    s->gray_block_size = s->lines_per_block * PIXELS_PER_LINE;

    /* try to get calibration */
    if(s->has_cal_buffer){
      DBG (15, "attach_one: scanner calibration\n");
    
      ret = load_calibration(s);
      if (ret != SANE_STATUS_GOOD) {
          DBG (5, "sane_start: ERROR: cannot calibrate, incompatible?\n");
          free (s->device_name);
          free (s);
          return ret;
      }
    }
    else{
      DBG (15, "attach_one: skipping calibration\n");
    }
  
    /* set SANE option 'values' to good defaults */
    DBG (15, "attach_one: init options\n");
  
    /* go ahead and setup the first opt, because 
     * frontend may call control_option on it 
     * before calling get_option_descriptor 
     */
    memset (s->opt, 0, sizeof (s->opt));
    for (i = 0; i < NUM_OPTIONS; ++i) {
        s->opt[i].name = "filler";
        s->opt[i].size = sizeof (SANE_Word);
        s->opt[i].cap = SANE_CAP_INACTIVE;
    }
  
    s->opt[OPT_NUM_OPTS].name = SANE_NAME_NUM_OPTIONS;
    s->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
    s->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
    s->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
    s->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
  
    DBG (15, "attach_one: init settings\n");
  
    /* we close the connection, so that another backend can talk to scanner */
    disconnect_fd(s);
  
    /* load info into sane_device struct */
    s->sane.name = s->device_name;
    s->sane.vendor = s->vendor_name;
    s->sane.model = s->product_name;
    s->sane.type = "scanner";
  
    s->next = scanner_devList;
    scanner_devList = s;
  
    DBG (10, "attach_one: finish\n");
  
    return SANE_STATUS_GOOD;
}
示例#5
0
文件: billingd.c 项目: selecli/squid
static int read_billing_info( int sock_fd )
{
	uint32_t billing_count = 0;
	char msgError[1024];
	fde *F = &fd_table[sock_fd];
	//static char billing_buff[102400];
	//static int32_t left_len = 0;
	
	// add by cwg at 2013-07-23
	char tmp_buff[102400];
	memset(tmp_buff, '\0', 102400);
	if (F->left_len > 0)
	{
		if (F->billing_buff)
		{
			memcpy(tmp_buff, F->billing_buff, F->left_len);
			free(F->billing_buff);
			F->billing_buff = NULL;
		}
		else
		{
			addInfoLog(0, "WARING: the left_len large 0,but billing_buff is NULL!");
		}
	}
	else
	{
		if (F->billing_buff)
		{
			memset(msgError, '\0', 1024);
			snprintf(msgError, 1024, "WARING: the left_len == 0, but billing_buff is not NULL! billing_buff:%s", F->billing_buff);
			addInfoLog(0, msgError);
			free(F->billing_buff);
			F->billing_buff = NULL;
		}
	}
	ssize_t len = read(sock_fd, tmp_buff + F->left_len, 10240);
	if( len == 0)
	{
		addInfoLog(0,"in read_billing_info, read_len ==0\n");
		goto fail;
	}
	else if( (len < 0) && (errno == EINTR) )
	{
		addInfoLog(0,"in read_billing_info, errno == EINTR\n");
		return 0;
	}
	else if( len < 0 )
	{
		addInfoLog(0,"in read_billing_info, read_len < 0\n");
		goto fail;
	}

	F->left_len += len;
	//F->billing_buff[F->left_len] = 0;
	// add by cwg at 2013-07-23
	tmp_buff[F->left_len] = 0;

	time_t current_time = time(NULL);
	delta_rcv_time = (int) difftime(current_time, last_rcv_ok);
	if (delta_rcv_time > 300) {
		addInfoLog(0, "Warning: billingd not received data over 300 seconds\n");
	}
	else if (delta_rcv_time < 0) {
		addInfoLog(0, "Warning: the interval of billingd received data is abnormal\n");
	}

	/* i do not find a good resulution for multi-squid */
	delta_rcv_time = 12;		// fixed me, this is bad !!

	last_rcv_ok = current_time;
	addInfoLog(1,tmp_buff);

	char *tmp;
	while( (tmp = memchr(tmp_buff, '\n', F->left_len)) != NULL) {
		char line[1024];
		memset(line, 0, 1024);
	
		assert((tmp - tmp_buff) < 1024);
		memcpy(line, tmp_buff, (tmp - tmp_buff));

		billing_count++;
		billing_line(line);

		tmp++;
		int cha = tmp - tmp_buff;
		if(cha < 1)
		{
			addInfoLog(0,"in read_billing_info, cha < 1\n");
			goto fail;
		}

		F->left_len -= cha;

		memmove(tmp_buff, tmp, F->left_len);
		tmp_buff[F->left_len] = 0;

	}
	// add by cwg at 2013-07-30  不为NULL 代表1 malloc成功了;2 被赋值过
	if (F->billing_buff) 
	{
		free(F->billing_buff);
	 	F->billing_buff = NULL;
	}
	if (F->left_len > 0)
	{
		// add by cwg at 2013-07-29
		F->billing_buff = malloc(F->left_len + 1);
		if (!F->billing_buff)
		{
			addInfoLog(0, "error: malloc() for billing_buff fail! so exit(-1)!!");
			exit(-1);
		}
		memset(F->billing_buff, '\0', F->left_len + 1);
		memcpy(F->billing_buff, tmp_buff, F->left_len);
	}

	if( F->left_len < 0 ) {
		addInfoLog(2,"[read_socket] left_len < 0");
		exit(0);
	}

	return 0;

fail:
	addInfoLog(0, "[read_socket] error\n");
	disconnect_fd(sock_fd);
	return -1;
}
示例#6
0
文件: rf_epoll.c 项目: selecli/squid
int rf_epoll_wait(epoll_handle_accept *accept_handler,epoll_handle_read_event *read_handler,epoll_handle_write_event *write_handler){
	int nfds;
	int i;
	
	rf_client *rfc;

	nfds = epoll_wait(kdpfd, events, MAX_EVENTS, EPOLL_TIMEOUT);
	if(nfds == -1) {
		if( errno != EINTR ) {
			cclog(2,"ERROR. {%s}\n", strerror(errno));
			return RF_ERR_EPOLL;
		}

		return RF_OK;
	} else if( 0 == nfds) {
		cclog(9,"epoll timeout!");
		return RF_OK;
	}

	int ret = -1;
	int fd;
	for( i = 0 ; i < nfds ; i++ ) {
		if( listen_fd == events[i].data.fd ) {
			accept_handler(listen_fd);
			continue;
		}

		fd = events[i].data.fd;
		rfc = &fd_table[fd];
		if(events[i].events & (EPOLLIN|EPOLLHUP|EPOLLERR)){
			ret = read_handler(fd);
			switch(ret){
				case RF_OK:
					cclog(5,"process success! fd(%d)",fd);
					break;
				case RF_ERR_PEER_CLOSE:
					cclog(2,"close peer socket! close fd(%d),ip(%s)",fd,get_peer_ip(fd));
				//add for async report dir refresh result
					if(rfc->type == RF_CLIENT_REPORT)
					{
						rf_set_session_report_status(fd, RF_SESSION_CLOSE);
					}
				//add for async report dir refresh result

					disconnect_fd(fd);
					break;
				case RF_CLOSE_REPORT:
					if(rfc->type == RF_CLIENT_REPORT)
					{
						cclog(2, "refreshd close report fd: [%d], peer_ip: [%s]", fd, get_peer_ip(fd));
						rf_set_session_report_status(fd, RF_SESSION_SUCCESS);
					}

					disconnect_fd(fd);
					break;
				default:
				//add for async report dir refresh result
					if(rfc->type == RF_CLIENT_REPORT)
					{
						rf_set_session_report_status(fd, RF_SESSION_FAILED);
					}
				//add for async report dir refresh result
					cclog(2,"proccess error! close fd(%d),ip(%s),ret(%d)",fd,get_peer_ip(fd),ret);
					disconnect_fd(fd);
					break;
			}
		}

		if(events[i].events & (EPOLLOUT|EPOLLHUP|EPOLLERR)){
			ret = write_handler(fd);
			switch(ret){
				case RF_OK:
					cclog(5,"process success! fd(%d),ip(%s)",fd,get_peer_ip(fd));
					break;
				case RF_ERR_PEER_CLOSE:
					cclog(2,"close peer socket! close fd(%d),ip(%s)",fd,get_peer_ip(fd));
				//add for async report dir refresh result
					if(rfc->type == RF_CLIENT_REPORT)
					{
						rf_set_session_report_status(fd, RF_SESSION_SUCCESS);
					}
				//add for async report dir refresh result

					disconnect_fd(fd);
					break;
				default:
					//add for async report dir refresh result
                                        rfc = &fd_table[fd];
                                        if(rfc->type == RF_CLIENT_REPORT)
                                        {
						rf_set_session_report_status(fd, RF_SESSION_FAILED);
                                        }
                                	//add for async report dir refresh result
					cclog(2,"proccess error! close fd(%d),ip(%s)",fd,get_peer_ip(fd));
					disconnect_fd(fd);
					break;
			}
		}

	}

	return RF_OK;
}