C++ cs_sleepms函数代码示例

static int32_t Azbox_Reset(struct s_reader *reader, ATR *atr)
{
  int32_t status;
  unsigned char tmp[512];

  memset(tmp, 0, sizeof(tmp));
  tmp[0] = 3;
  tmp[1] = 1;

  ioctl(reader->handle, SCARD_IOC_WARMRESET, &tmp);

  cs_sleepms(500);

  while ((status = _GetStatus(reader, NULL)) != 3)
    cs_sleepms(50);

  tmp[0] = 0x02;
  tmp[1] = sc_mode;
  status = ioctl(reader->handle, SCARD_IOC_CHECKCARD, &tmp);

  memset(tmp, 0, sizeof(tmp));
  tmp[0] = 1;

  int32_t atr_len = ioctl(reader->handle, SCARD_IOC_CHECKCARD, &tmp);
  if (ATR_InitFromArray(atr, tmp, atr_len) == ERROR)
    return 0;

   cs_sleepms(500);

   return OK;
}

static void cs_waitforcardinit(void)
{
	if (cfg.waitforcards)
	{
		cs_log("waiting for local card init");
		int32_t card_init_done;
		do {
			card_init_done = 1;
			struct s_reader *rdr;
			LL_ITER itr = ll_iter_create(configured_readers);
			while((rdr = ll_iter_next(&itr))) {
				if (rdr->enable && !is_cascading_reader(rdr) && (rdr->card_status == CARD_NEED_INIT || rdr->card_status == UNKNOWN)) {
					card_init_done = 0;
					break;
				}
			}

			if (!card_init_done)
				cs_sleepms(300); // wait a little bit
			//alarm(cfg.cmaxidle + cfg.ctimeout / 1000 + 1);
		} while (!card_init_done && !exit_oscam);
		if (cfg.waitforcards_extra_delay>0 && !exit_oscam)
			cs_sleepms(cfg.waitforcards_extra_delay);
		cs_log("init for all local cards done");
	}
}

static void arm_switch_led_from_thread(int32_t led, int32_t action) {
	if (action < 2) { // only LED_ON and LED_OFF
		char led_file[256];
		if (!arm_init_led_file(arm_led_type, led, led_file, sizeof(led_file)))
			return;
		FILE *f = fopen(led_file, "w");
		if (!f)
			return;
		fprintf(f, "%d", action);
		fclose(f);
	} else { // LED Macros
		switch(action){
		case LED_DEFAULT:
			arm_switch_led_from_thread(LED1A, LED_OFF);
			arm_switch_led_from_thread(LED1B, LED_OFF);
			arm_switch_led_from_thread(LED2, LED_ON);
			arm_switch_led_from_thread(LED3, LED_OFF);
			break;
		case LED_BLINK_OFF:
			arm_switch_led_from_thread(led, LED_OFF);
			cs_sleepms(100);
			arm_switch_led_from_thread(led, LED_ON);
			break;
		case LED_BLINK_ON:
			arm_switch_led_from_thread(led, LED_ON);
			cs_sleepms(300);
			arm_switch_led_from_thread(led, LED_OFF);
			break;
		}
	}
}

/*
 This function allows to reinit the in-memory loghistory with a new size.
*/
void cs_reinit_loghist(uint32_t size)
{
	char *tmp = NULL, *tmp2;
	if(size != cfg.loghistorysize){
		if(size == 0 || cs_malloc(&tmp, size, -1)){
			cs_writelock(&loghistory_lock);
			tmp2 = loghist;
			// On shrinking, the log is not copied and the order is reversed
			if(size < cfg.loghistorysize){
				cfg.loghistorysize = size;
				cs_sleepms(20);	// Monitor or webif may be currently outputting the loghistory but don't use locking so we sleep a bit...
				loghistptr = tmp;
				loghist = tmp;
			} else {
				if(loghist){
					memcpy(tmp, loghist, cfg.loghistorysize);
					loghistptr = tmp + (loghistptr - loghist);
				} else loghistptr = tmp;
				loghist = tmp;
				cs_sleepms(20);	// Monitor or webif may be currently outputting the loghistory but don't use locking so we sleep a bit...
				cfg.loghistorysize = size;
			}
			cs_writeunlock(&loghistory_lock);
			if(tmp2 != NULL) add_garbage(tmp2);
		}
	}
}

int32_t Cool_Reset (struct s_reader *reader, ATR * atr)
{
	//set freq to reader->cardmhz if necessary
	uint32_t clk;
	int32_t ret;

	ret = cnxt_smc_get_clock_freq (specdev()->handle, &clk);
	check_error("cnxt_smc_get_clock_freq", ret);
	if (clk/10000 != reader->cardmhz) {
		cs_debug_mask(D_DEVICE,"COOL: %s clock freq: %i, scheduling change to %i for card reset", reader->label, clk, reader->cardmhz*10000);
		call (Cool_SetClockrate(reader, reader->cardmhz));
	} 

	//reset card
	ret = cnxt_smc_reset_card (specdev()->handle, ATR_TIMEOUT, NULL, NULL);
	check_error("cnxt_smc_reset_card", ret);
	cs_sleepms(50);
	int32_t n = 40;
	unsigned char buf[40];
	ret = cnxt_smc_get_atr (specdev()->handle, buf, &n);
	check_error("cnxt_smc_get_atr", ret);
		
	call (!ATR_InitFromArray (atr, buf, n) == ATR_OK);
	{
		cs_sleepms(50);
		return OK;
	}
}

void log_list_thread(void)
{
	char buf[LOG_BUF_SIZE];
	int last_count=ll_count(log_list), count, grow_count=0, write_count;
	do {
		LL_ITER it = ll_iter_create(log_list);
		struct s_log *log;
		write_count = 0;
		while ((log=ll_iter_next_remove(&it))) {
			int8_t do_flush = ll_count(log_list) == 0; //flush on writing last element

			cs_strncpy(buf, log->txt, LOG_BUF_SIZE);
			if (log->direct_log)
				cs_write_log(buf, do_flush);
			else
				write_to_log(buf, log, do_flush);
			free(log->txt);
			free(log);

			//If list is faster growing than we could write to file, drop list:
			write_count++;
			if (write_count%10000 == 0) { //check every 10000 writes:
				count = ll_count(log_list);
				if (count > last_count) {
					grow_count++;
					if (grow_count > 5) { //5 times still growing
						cs_write_log("------------->logging temporary disabled (30s) - too much data!\n", 1);
						cfg.disablelog = 1;
						ll_iter_reset(&it);
						while ((log=ll_iter_next_remove(&it))) { //clear log
							free(log->txt);
							free(log);
						}
						cs_sleepms(30*1000);
						cfg.disablelog = 0;

						grow_count = 0;
						last_count = 0;
						break;
					}
				}
				else
					grow_count = 0;
				last_count = count;
			}
		}
		cs_sleepms(250);
	} while(1);
}

void IO_Serial_Ioctl_Lock(struct s_reader * reader, int32_t flag)
{
  if ((reader->typ != R_DB2COM1) && (reader->typ != R_DB2COM2)) return;
  if (!flag)
    oscam_sem=0;
  else while (oscam_sem!=reader->typ)
  {
    while (oscam_sem)
			if (reader->typ == R_DB2COM1)
				cs_sleepms(6);
			else
				cs_sleepms(8);
    oscam_sem=reader->typ;
    cs_sleepms(1);
  }
}

void cs_disable_log(int8_t disabled)
{
	if(cfg.disablelog != disabled)
	{
		if(disabled && logStarted)
		{
			cs_log("Stopping log...");
			log_list_flush();
		}
		cfg.disablelog = disabled;
		if(disabled)
		{
			if(logStarted)
			{
				if(syslog_socket != -1)
				{
					close(syslog_socket);
					syslog_socket = -1;					
				}
				
				cs_sleepms(20);
				cs_close_log();
			}
		}
		else
		{
			init_syslog_socket();
			cs_open_logfiles();
		}
	}
}

bool cardreader_init(struct s_reader *reader) {
	struct s_client *client = reader->client;
	client->typ = 'r';
	set_localhost_ip(&client->ip);
	while (cardreader_device_init(reader) == 2) {
		int8_t i = 0;
		do {
			cs_sleepms(2000);
			if (!ll_contains(configured_readers, reader) || !is_valid_client(client) || reader->enable != 1)
				return false;
			i++;
		} while (i < 30);
	}
	if (reader->mhz > 2000) {
		rdr_log(reader, "Reader initialized (device=%s, detect=%s%s, pll max=%.2f Mhz, wanted cardmhz=%.2f Mhz",
			reader->device,
			reader->detect & 0x80 ? "!" : "",
			RDR_CD_TXT[reader->detect & 0x7f],
			(float)reader->mhz /100,
			(float)reader->cardmhz / 100);
	} else {
		rdr_log(reader, "Reader initialized (device=%s, detect=%s%s, mhz=%d, cardmhz=%d)",
			reader->device,
			reader->detect & 0x80 ? "!" : "",
			RDR_CD_TXT[reader->detect & 0x7f],
			reader->mhz,
			reader->cardmhz);
	}
	return true;
}

/* Checks if the date of the system is correct and waits if necessary. */
static void init_check(void){
	char *ptr = __DATE__;
	int32_t month, year = atoi(ptr + strlen(ptr) - 4), day = atoi(ptr + 4);
	if(day > 0 && day < 32 && year > 2010 && year < 9999){
		struct tm timeinfo;
		char months[12][4] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
		for(month = 0; month < 12; ++month){
			if(!strncmp(ptr, months[month], 3)) break;
		}
		if(month > 11) month = 0;
		memset(&timeinfo, 0, sizeof(timeinfo));
		timeinfo.tm_mday = day;
		timeinfo.tm_mon = month;
		timeinfo.tm_year = year - 1900;
		time_t builddate = mktime(&timeinfo) - 86400;
	  int32_t i = 0;
	  while(time((time_t*)0) < builddate){
	  	if(i == 0) cs_log("The current system time is smaller than the build date (%s). Waiting up to %d seconds for time to correct", ptr, cs_waittime);
	  	cs_sleepms(1000);
	  	++i;
	  	if(i > cs_waittime){
	  		cs_log("Waiting was not successful. OSCam will be started but is UNSUPPORTED this way. Do not report any errors with this version.");
				break;
	  	}
	  }
	  // adjust login time of first client
	  if(i > 0) first_client->login=time((time_t *)0);
	}
}

void cs_lock_destroy(CS_MUTEX_LOCK *l)
{
	if (!l || !l->name || l->flag) return;

	cs_rwlock_int(l, WRITELOCK);
#ifdef WITH_DEBUG
	const char *old_name = l->name;
#endif
	l->name = NULL; //No new locks!
	cs_rwunlock_int(l, WRITELOCK);
	
	//Do not destroy when having pending locks!
	int32_t n = (l->timeout/10)+2;
	while ((--n>0) && (l->writelock || l->readlock)) cs_sleepms(10);

	cs_rwlock_int(l, WRITELOCK);
	l->flag++; //No new unlocks!
	cs_rwunlock_int(l, WRITELOCK);
	
#ifdef WITH_DEBUG
	if (!n && old_name != LOG_LIST)
		cs_log_nolock("WARNING lock %s destroy timed out.", old_name);
#endif

	pthread_mutex_destroy(&l->lock);
	pthread_cond_destroy(&l->writecond);
	pthread_cond_destroy(&l->readcond);
#ifdef WITH_MUTEXDEBUG
	cs_debug_mask_nolock(D_TRACE, "lock %s destroyed", l->name);
#endif
}

int32_t Cool_FastReset_With_ATR (struct s_reader *reader, ATR * atr)
{
	int32_t n = 40, ret;
	unsigned char buf[40];

	//reset card
	ret = cnxt_smc_reset_card (specdev()->handle, ATR_TIMEOUT, NULL, NULL);
	check_error("cnxt_smc_reset_card", ret);
	cs_sleepms(50);
	ret = cnxt_smc_get_atr (specdev()->handle, buf, &n);
	check_error("cnxt_smc_get_atr", ret);

	call (!ATR_InitFromArray (atr, buf, n) == ATR_OK);
	{
		cs_sleepms(50);
		return OK;
	}
}

int32_t Cool_Reset (ATR * atr)
{
	call (Cool_SetClockrate(357));

	//reset card
	int32_t timeout = 5000; // Timout in ms?
	call (cnxt_smc_reset_card (specdev()->handle, ATR_TIMEOUT, NULL, NULL));
	cs_sleepms(50);
	int32_t n = 40;
	unsigned char buf[40];
	call (cnxt_smc_get_atr (specdev()->handle, buf, &n));
		
	call (!ATR_InitFromArray (atr, buf, n) == ATR_OK);
	{
		cs_sleepms(50);
		return OK;
	}
}

static void log_list_flush(void)
{
	pthread_cond_signal(&log_thread_sleep_cond);
	int32_t i = 0;
	while(ll_count(log_list) > 0 && i < 200)
	{
		cs_sleepms(5);
		++i;
	}
}

static int32_t oscam_ser_write(struct s_client *client, const uchar * const buf, int32_t n)
{
  int32_t i;
  for (i=0; (i<n) && (oscam_ser_poll(POLLOUT, client)); i++)
  {
    if (client->serialdata->oscam_ser_delay)
      cs_sleepms(client->serialdata->oscam_ser_delay);
    if (write(client->pfd, buf+i, 1)<1)
      break;
  }
  return(i);
}