static int
answer_peer(struct dns_query *query, uint8_t *buf)
{
uint32_t address;
struct tm tm;
uint8_t *p;
struct dnshdr *resp;
get_local_time(&tm);
address = htonl(((tm.tm_mon + 1) << 24)
+ (tm.tm_mday << 16)
+ (tm.tm_hour << 8)
+ tm.tm_min);
memcpy(buf, query->packet,
sizeof(struct dnshdr) + query->qlen + 2 + 2);
p = buf + sizeof(struct dnshdr) + query->qlen + 2 + 2;
p += fill_rr_raw(p, sizeof(struct dnshdr),
TYPE_A, CLASS_IN,
(uint32_t) 0, 4,
(uint8_t *) &query->saddr);
p += fill_rr_raw(p, sizeof(struct dnshdr),
TYPE_A, CLASS_IN,
(uint32_t) 0, 4,
(uint8_t *) &address);
resp = (struct dnshdr *) buf;
RESP_SET(resp, 2, RCODE_NOERROR);
return p - buf;
}
static void newcamd_redraw_dt(BOOL update)
{
date_time dt;
char stringTemp[50];
UINT16 *unistr=NULL;
UINT16 unistr_dest[50]={0};
UINT16 uni_string[300]={0};
get_local_time(&dt);
memset(unistr_dest,0,sizeof(unistr_dest));
memset(uni_string,0,sizeof(uni_string));
memset(stringTemp,0,sizeof(stringTemp));
unistr = OSD_GetUnicodeString(RS_TIME);
sprintf(stringTemp," %02d:%02d",dt.hour,dt.min);
ComAscStr2Uni(stringTemp,unistr_dest);
ComUniStrCopyChar(&uni_string,(UINT16 *)unistr);
ComUniStrCat(&uni_string,unistr_dest);
OSD_SetTextFieldContent(&newcamd_txt_time, STRING_UNICODE,uni_string);
if(update)
{
OSD_DrawObject((POBJECT_HEAD)&newcamd_txt_time,C_DRAW_SIGN_EVN_FLG |C_UPDATE_ALL);
}
}
/*********************************************************
* note: write log file
* @param filename[in]: log path
* @param maxsize[in]: log max size
* @param buffer[in]: log content
* @param buf_size[in]: log content size
*********************************************************/
void write_log_file(char* filename, long max_size, char* buffer, unsigned buf_size)
{
if (filename != NULL && buffer != NULL)
{
// log size is biger than max_size, delete log file
long length = get_file_size(filename);
if (length > max_size)
{
unlink(filename); // 删除文件
}
// write buffer in log
{
FILE *fp;
fp = fopen(filename, "at+");
if (fp != NULL)
{
char now[32];
memset(now, 0, sizeof(now));
get_local_time(now);
sprintf(now, "%s\n", now);
fwrite(now, strlen(now)+1, 1, fp);
fwrite(buffer, buf_size, 1, fp);
fclose(fp);
fp = NULL;
}
}
}
}
/**
* @Ex: "2013-01-10T01:09:57+08:00"
*/
static int get_iso8601_time(char *output)
{
struct timeval tv;
struct timezone tz;
char buff[TIMESTAMP_LENGTH] = {0};
char timestamp[TIMESTAMP_LENGTH + 4] = {0};
int tz_min = 0;
if (NULL == output)
return -1;
get_local_time(buff);
gettimeofday(&tv, &tz);
tz_min = abs(tz.tz_minuteswest);
if (0 == tz.tz_minuteswest) {
snprintf(timestamp, sizeof(timestamp), "%sZ", buff);
} else {
snprintf(timestamp, sizeof(timestamp), "%s%s%02d:%02d", buff,
(tz.tz_minuteswest < 0) ? "+" : "-",
tz_min / 60, tz_min % 60);
}
memcpy(output, timestamp, TIMESTAMP_LENGTH + 4);
return 0;
}
void win_time_enter_key(POBJECT_HEAD pObj,UINT8 id)
{
INT32 hoffset, moffset;
SYSTEM_DATA* p_sys_data=sys_data_get();
OSD_RECT rect;
COM_POP_LIST_PARAM_T param;
rect.uLeft=CON_L+TXTS_L_OF;
rect.uWidth=TXTS_W;
rect.uHeight=MENU_TIMESET_GMT_OFFESET_POPUP_H;
param.selecttype = POP_LIST_SINGLESELECT;
switch(id)
{
case MENU_TIMESET_GMT_OFFESET:
rect.uHeight = MENU_TIMESET_GMT_OFFESET_POPUP_H;
rect.uTop=CON_T + (CON_H + CON_GAP)*1;
param.cur=p_sys_data->local_time.GMToffset_count;
p_sys_data->local_time.GMToffset_count = win_com_open_sub_list(POP_LIST_MENU_TIME,&rect,¶m);
win_time_set_GMT_Offset_string(p_sys_data->local_time.GMToffset_count);
OSD_TrackObject(pObj,C_UPDATE_ALL);
sys_data_gmtoffset_2_hmoffset(&hoffset, &moffset);
set_STC_offset( hoffset, moffset, 0);
get_local_time(&win_time_local_time);
set_time_data();
set_time_clock();
OSD_DrawObject((POBJECT_HEAD )&time_item_con4,C_UPDATE_ALL);
OSD_DrawObject((POBJECT_HEAD )&time_item_con5,C_UPDATE_ALL);
win_time_set_time_zone_citys(TRUE);
break;
}
}
void power_on_process(void)
{
date_time dt; //ctchen
SYSTEM_DATA* sys_data;
struct sf_panel_attr panel_attr;
sys_data = sys_data_get();
pan_io_control(g_pan_dev, PAN_DRIVER_GET_ATTRIBUTE, &panel_attr);
if (panel_attr.type == SF_PANEL_TYPE_LED)
{
sf_panel_display_string("----", 4, TRUE);
}
else
{
sf_panel_display_string(" REBOOT ", 8, TRUE);
}
pan_close(g_pan_dev);
if(sys_data->local_time.buseGMT)
get_STC_time(&sys_data->sys_dt);
else
get_local_time(&sys_data->sys_dt); //ctchen
sys_data->bstandmode = 0;
sys_data_save(1);
sys_watchdog_reboot();
}
void *thread_fun(void *arg)
{
struct sigaction act,oact;//设置信号
act.sa_handler = sig_alrm;//
act.sa_flags = 0;
sigemptyset(&act.sa_mask);
// sigaction(SIGALRM, &act, &oact);
while(1)
{
printf("pid=%lu tid=%lu\n", getpid(), pthread_self());
unsigned long ret;
ret=get_file_size("2.cpp");
//sleep(3);
struct itimerval itv;
itv.it_interval.tv_sec = 5;
itv.it_interval.tv_usec = 0;
itv.it_value.tv_sec = 5;
itv.it_value.tv_usec = 0;
setitimer(ITIMER_REAL, &itv, &oldtv);
if(ret>0)
{
printf("file is too big.....\n");
get_local_time();
file_cp("1","2");
// sleep(3);
}
// sleep(3);
}
}
int get_file_name(char **buffer)
{
char *buffer_tmp = NULL;
char srval[5] = {0, 0, 0, 0, 0};
int rval = 0;
int size = 0;
srand(time(NULL));
rval = rand_x_y(1000, 9999);
sprintf(srval, "%d", rval);
size = get_local_time(&buffer_tmp, 0);
assert(*buffer == NULL);
if((*buffer = calloc(size + 1 + 4, sizeof(char))) == NULL)
{
perror("calloc");
return -1;
}
strcpy(*buffer, buffer_tmp);
strcat(*buffer, srval);
return (size + 4);
}
//! Get the local day as a ymd_type
static typename date_type::ymd_type local_day_ymd()
{
::std::tm* curr = get_local_time();
return ymd_type(curr->tm_year + 1900,
curr->tm_mon + 1,
curr->tm_mday);
}
//! Get the local day as a ymd_type
static typename date_type::ymd_type local_day_ymd()
{
::std::tm result;
::std::tm* curr = get_local_time(result);
return ymd_type(static_cast<unsigned short>(curr->tm_year + 1900),
static_cast<unsigned short>(curr->tm_mon + 1),
static_cast<unsigned short>(curr->tm_mday));
}
void win_timerset_set_currenttime(BOOL update)
{
TEXT_FIELD* txt;
char str[30];
date_time dt;
get_local_time(&dt);
txt = &timer_cur_datetime;
sprintf(str,"%d:%02d %04d-%02d-%02d",dt.hour,dt.min,dt.year,dt.month,dt.day);
OSD_SetTextFieldContent(txt, STRING_ANSI, (UINT32)str);
if(update)
OSD_DrawObject((POBJECT_HEAD)txt, C_UPDATE_ALL);
}
void set_kaon_ttx_time(UINT8 * temp)
{
date_time dt;
get_local_time(&dt);
temp[0] = dt.hour/10 + '0';
temp[1] = dt.hour % 10 + '0';
temp[2] = ':';
temp[3] = dt.min /10 + '0';
temp[4] = dt.min% 10 + '0';
temp[5] = ':';
temp[6] = dt.sec / 10 + '0';
temp[7] = dt.sec % 10 + '0';
}
static int get_index_file_name(char* filename, int index, char* path, char* ext)
{
struct tm tm;
int hour, minute;
get_local_time(&tm);
hour = tm.tm_hour;
minute = tm.tm_min;
sprintf(filename, "%s/%02d%02d%04d.%s", path, hour, minute, index, ext);
return 0;
}
int main(int argc, char *argv[])
{
int local_time = 0;
int remote_time = 0;
int ret = 0;
local_time = get_local_time();
remote_time = time_str2int(time_string);
ret = check_time_val(local_time, remote_time);
fprintf(stderr, "localtime = [%d], remote_time = [%d], the ret = [%d]\n",
local_time, remote_time, ret);
return 0;
}
int main()
{
pthread_t thread;
pthread_create(&thread, NULL, thread_fun, NULL);
unsigned long ret = get_file_size("1.cpp");
printf("file size is %d\n",ret);
get_local_time();
signal(SIGALRM, signal_handler);
//sleep(3);
//raise(SIGALRM);//向某一进程发送信号，由进程处理
// pthread_kill(thread, SIGALRM);//向某一线程发送信号，由接受线程处理
pthread_join(thread, NULL);
//进程接受信号和线程接受信号不同
}
static int get_index_folder_name(char* foldername, int index, char* path)
{
struct tm tm;
int year,month,day;
get_local_time(&tm);
year = tm.tm_year % 10;
month = tm.tm_mon + 1;
day = tm.tm_mday;
sprintf(foldername, "%s/%03d%d%02d%02d", path, index, year, month, day);
return 0;
}
static int get_date_folder_name(char* foldername, char* path)
{
struct tm tm;
int year,month,day;
get_local_time(&tm);
year = tm.tm_year + 1900;
month = tm.tm_mon + 1;
day = tm.tm_mday;
sprintf(foldername, "%s/%4d%02d%02d", path, year, month, day);
return 0;
}
void msg_send(void)
{
// if ((msg.root_id == 0xFFFF) && (++heart_beats >= ROOT_TIMEOUT))
// {
// PRINTF("FTSP root timeout, declaring myself the root\n");
// seq_num = 0;
// msg.root_id = node_id;
// }
//
if ((msg.root_id != 0xFFFF) && ((state & STATE_SENDING) == 0))
{
state |= STATE_SENDING;
rtimer_long_clock_t local_time, global_time;
local_time = get_local_time();
global_time = local_to_global(local_time);
if (msg.root_id == node_id)
{
if ((long)(local_time - local_average) >= 0x20000000)
{
local_average = local_time;
offset_average = global_time - local_time;
}
}
// else
// {
// if (heart_beats >= ROOT_TIMEOUT)
// {
// PRINTF("FTSP: root timeout, declaring myself the root\n");
// heart_beats = 0;
// msg.root_id = node_id;
// ++seq_num;
// }
// }
if ((num_entries < ENTRY_SEND_LIMIT) && (msg.root_id != node_id))
{
++heart_beats;
state &= ~STATE_SENDING;
}
else
{
process_post(&ftsp_send_process, send_ready, NULL);
}
}
}
static int get_time_file_name(char* filename, char* path, char* postfix, char* ext)
{
struct tm tm;
int hour, minute, second;
get_local_time(&tm);
hour = tm.tm_hour;
minute = tm.tm_min;
second = tm.tm_sec;
if (postfix)
sprintf(filename, "%s/%02d%02d%02d%s.%s", path, hour, minute, second, postfix, ext);
else
sprintf(filename, "%s/%02d%02d%02d.%s", path, hour, minute, second, ext);
return 0;
}
void * create_new_elem_hist(char *url, char *ipcli,
int staterr)
{
struct elem_hist *elem = NULL;
if((elem = calloc(1, sizeof(struct elem_hist))) == NULL)
{
perror("calloc");
return NULL;
}
// Création et initialisation du champs q_url.
if((elem->q_url = calloc(strlen(url) + 1, sizeof(char))) == NULL)
{
perror("calloc");
return NULL;
}
strcpy(elem->q_url, url);
// Création et initialisation du champs q_ipcli.
if((elem->q_ipcli = calloc(strlen(ipcli) + 1, sizeof(char))) == NULL)
{
perror("calloc");
return NULL;
}
strcpy(elem->q_ipcli, ipcli);
// Initialisation du champs q_staterr.
elem->q_staterr = staterr;
if(get_local_time(&(elem->q_date), 0) == -1)
{
fprintf(stderr, "L'appel à get_local_time a échoué.\n");
return NULL;
}
// Initialisation du champs q_next.
elem->q_next = NULL;
return (void *)elem;
}
static PRESULT time_con_callback(POBJECT_HEAD pObj, VEVENT event, UINT32 param1, UINT32 param2)
{
PRESULT ret = PROC_PASS;
UINT32 i;
UINT8 unact;
CONTAINER* cont = (CONTAINER*)pObj;
UINT8 id = OSD_GetObjID(pObj);
SYSTEM_DATA* p_sys_data;
p_sys_data=sys_data_get();
switch(event)
{
case EVN_PRE_OPEN:
wincom_open_subtitle((POBJECT_HEAD)&win_time_con,RS_SYS_LOCAL_TIMER_SET/*RS_SYSTEM_TIME*/, 0);
win_time_set_GMT_enable_string(p_sys_data->local_time.buseGMT);
win_time_set_Summer_string(p_sys_data->local_time.SummerTime);
win_time_set_Display_string(p_sys_data->local_time.TimeDisplay);
win_time_set_GMT_Offset_string(p_sys_data->local_time.GMToffset_count);
get_local_time(&win_time_local_time);
set_time_data();
set_time_clock();
win_time_switch_GMT_Type(p_sys_data->local_time.buseGMT);
win_time_set_time_zone_citys(FALSE);
OSD_SetContainerFocus((CONTAINER*)pObj,1);
break;
case EVN_POST_OPEN:
break;
case EVN_PRE_CLOSE:
sys_data_save(1);
enable_summer_time(p_sys_data->local_time.buseGMT && p_sys_data->local_time.SummerTime);
/* Make OSD not flickering */
*((UINT32*)param2) &= ~C_CLOSE_CLRBACK_FLG;
break;
case EVN_POST_CLOSE:
wincom_close_subtitle();
OSD_TrackObject( (POBJECT_HEAD) &g_win_mainmenu, C_UPDATE_ALL);
break;
}
return ret;
}
void LogFile::write(const string& error)
{
get_local_time();
path_initialization();
stringstream buf;
char* day = new char [2];
buf << struct_local_time.tm_mday;
buf >> day;
ofstream fout(path + "\\" + day + ".log", ios_base::app);
delete[] day;
fout << struct_local_time.tm_mday << "-" << struct_local_time.tm_mon + 1 << "-" << struct_local_time.tm_year + 1900 << "\n"
<< struct_local_time.tm_hour << ":" << struct_local_time.tm_min << ":" << struct_local_time.tm_sec << "\n"
<< error << "\n\n";
fout.close();
}
/*
return value:
-1 : wakeup_year <= 2000 || wakeup_year>2100
-2 : wakeup_month<0 || wakeup_month>12
-3 : wakeup_day not valied in the wakeup_year & wakeup_month
-4 : on time hour > 23
-5 : on timer minute > 59
-6 : duration minute > 59
-7 : add timer the wakeup date & time < current time
-8: add timer conflict with other timers
*/
INT32 win_timerset_check_and_save(void)
{
EDIT_FIELD *edf;
UINT16 ch_idx,ch_cnt;
P_NODE p_node;
date_time dt,wkdt;
UINT32 val,duration;
INT32 ret;
TIMER_SET_CONTENT* timer;
timer = &timer_set;
timer->timer_mode = TIMER_MODE;
timer->timer_service = TIMER_SERVICE_TYPE;
if(timer->timer_service == TIMER_SERVICE_MESSAGE)
timer->wakeup_message = TIMER_SERVICE_INFO;
else
{
get_prog_at(TIMER_SERVICE_INFO,&p_node);
timer->wakeup_channel = p_node.prog_id;
#ifdef DVR_PVR_SUPPORT
if(timer->timer_service == TIMER_SERVICE_DVR_RECORD)
{
timer->wakeup_message = TIMER_REC_TYPE;
}
#endif
}
edf = &timer_edf_wakeupdate;
OSD_GetEditFieldIntValue(edf,&val);
wkdt.year = val / 10000;
val -= wkdt.year*10000;
wkdt.month = val / 100;
val -= wkdt.month*100;
wkdt.day = val;
wkdt.weekday = OSD_GetMultiselSel(&timer_msel_wakeupweekday);
edf = &timer_edf_wakeuptime;
OSD_GetEditFieldIntValue(edf,&val);
wkdt.hour = val/100;
val -= wkdt.hour*100;
wkdt.min = val;
wkdt.sec = 0;
ret = api_check_valid_date(wkdt.year,wkdt.month,wkdt.day);
if(ret != 0)
return ret;
if(wkdt.hour > 23)
return -4;
if(wkdt.min>59)
return -5;
if(timer_set_check_starttime_flag)
{
if(timer->timer_mode != TIMER_MODE_OFF)
{
get_local_time(&dt);
if(api_compare_day_time(&wkdt,&dt) < 0)
return -7;
}
}
else
{
if(timer->timer_mode != TIMER_MODE_OFF)
{
/*
if(timer->wakeup_state == TIMER_STATE_RUNING)
{
}
*/
}
}
if(timer->timer_mode != TIMER_MODE_OFF)
{
timer->wakeup_year = wkdt.year;
timer->wakeup_month= wkdt.month;
timer->wakeup_day = wkdt.day;
timer->wakeup_time = wkdt.hour*60 + wkdt.min;
}
edf = &timer_edf_duration;
OSD_GetEditFieldIntValue(edf,&val);
duration = val/100*60 + val%100;
if(timer->timer_service == TIMER_SERVICE_MESSAGE)
timer->wakeup_duration_time = 0;
else
{
if(val % 100>59)
return -6;
timer->wakeup_duration_time = duration;
}
ret = IsValidTimer(timer);
if(ret==0)
return -8;
return 0;
}
BOOL win_timerset_open(TIMER_SET_CONTENT* settimer,TIMER_SET_CONTENT* rettimer,BOOL check_starttime)
{
POBJECT_HEAD pObj = (POBJECT_HEAD)&g_win_timerset;
PRESULT bResult = PROC_LOOP;
UINT32 hkey;
UINT8 cur_mode,mode;
UINT8 group_idx;
date_time dt,dt1;
BOOL old_value = ap_enable_key_task_get_key(TRUE);
sys_data_check_channel_groups();
cur_mode = sys_data_get_cur_chan_mode();
group_idx = sys_data_get_cur_group_index();
timer_set_ok_cancel_flag = 0;
MEMSET(&timer_set,0,sizeof(TIMER_SET_CONTENT));
if(settimer != NULL)
MEMCPY(&timer_set,settimer,sizeof(TIMER_SET_CONTENT));
if(timer_set.timer_mode != TIMER_MODE_OFF
&& timer_set.timer_service !=TIMER_SERVICE_MESSAGE)
{
if(timer_set.wakeup_chan_mode>1)
timer_set.wakeup_chan_mode = 1;
mode = timer_set.wakeup_chan_mode;
}
else
{
mode = cur_mode;
timer_set.wakeup_chan_mode = cur_mode;
}
if(timer_set.timer_mode == TIMER_MODE_OFF)
{
timer_set_modify_add_flag = TIMER_ADD;
timer_set_check_starttime_flag = 1;
}
else
{
timer_set_modify_add_flag = TIMER_MODIFY;
timer_set_check_starttime_flag = 1;
}
get_local_time(&dt1);
dt1.min = dt1.min/10*10;
dt1.sec = 0;
convert_time_by_offset(&dt,&dt1,0,10);
if(timer_set_modify_add_flag == TIMER_ADD)
{
timer_set.wakeup_year = dt.year;
timer_set.wakeup_month = dt.month;
timer_set.wakeup_day = dt.day;
timer_set.wakeup_time = dt.hour * 60 + dt.min;
timer_set.wakeup_state = TIMER_STATE_READY;
}
if(timer_set.timer_service == TIMER_SERVICE_MESSAGE)
timer_set.wakeup_duration_time = 0;
sys_data_set_cur_chan_mode(mode);
sys_data_change_group(0);
OSD_SetContainerFocus(&g_win_timerset, TIMER_MODE_ID);
OSD_ObjOpen(pObj, MENU_OPEN_TYPE_OTHER);
while(bResult != PROC_LEAVE)
{
hkey = ap_get_key_msg();
if(hkey == INVALID_HK || hkey == INVALID_MSG)
{
win_timerset_set_currenttime(TRUE);
continue;
}
bResult = OSD_ObjProc(pObj, (MSG_TYPE_KEY<<16),hkey, 0);
}
if(timer_set_ok_cancel_flag)
MEMCPY(rettimer,&timer_set,sizeof(TIMER_SET_CONTENT));
sys_data_set_cur_chan_mode(cur_mode);
sys_data_change_group(group_idx);
sys_data_save(1);
ap_enable_key_task_get_key(old_value);
return timer_set_ok_cancel_flag;
}
void krb_tgsreq_send(KRB_CONTEXT* krb_ctx, uint8 errcode)
{
KrbTGSREQ* krb_tgsreq;
KrbAPREQ* krb_apreq;
PAData** pa_data;
Authenticator* krb_auth;
STREAM* s;
STREAM* sapreq;
rdpBlob msg;
uint32 curlen, totlen, tmp;
uint8 *bm;
bm = NULL;
totlen = tmp = 0;
krb_tgsreq = krb_tgsreq_new(krb_ctx, errcode);
krb_auth = xnew(Authenticator);
pa_data = krb_tgsreq->padata;
s = stream_new(4096);
sapreq = stream_new(2048);
//Begin write asn1 data reversely into stream
stream_seek(s, 4095);
stream_seek(sapreq, 2047);
/* KDC-REQ-BODY (TAG 4) */
totlen += krb_encode_req_body(s, &(krb_tgsreq->req_body), krb_tgsreq->type);
stream_get_mark(s, bm);
tmp = totlen;
totlen += krb_encode_contextual_tag(s, 4, totlen);
msg.data = bm;
msg.length = tmp;
/* Authenticator */
krb_auth->avno = KRB_VERSION;
krb_auth->cname = krb_ctx->cname;
krb_auth->crealm = krb_ctx->realm;
krb_auth->cksumtype = get_cksum_type(krb_ctx->enctype);
krb_auth->cksum = crypto_kdcmsg_cksum(&msg, krb_ctx->askey, 6); //RFC4757 section 3 for msgtype (T=6)
krb_auth->ctime = krb_tgsreq->req_body.from;
krb_auth->cusec = 0;
crypto_nonce((uint8*)&(krb_auth->seqno), 4);
/* PA-TGS-REQ */
krb_apreq = krb_apreq_new(krb_ctx, &(krb_ctx->asticket), krb_auth);
curlen = krb_encode_apreq(sapreq, krb_apreq);
msg.data = sapreq->p;
msg.length = curlen;
(*pa_data)->type = 1;
(*pa_data)->value = msg;
/* PA-DATA (TAG 3) */
curlen = krb_encode_padata(s, pa_data);
totlen += curlen + krb_encode_contextual_tag(s, 3, curlen);
/* MSGTYPE (TAG 2) */
totlen += krb_encode_uint8(s, 2, krb_tgsreq->type);
/* VERSION NO (TAG 1) */
totlen += krb_encode_uint8(s, 1, krb_tgsreq->pvno);
totlen += krb_encode_sequence_tag(s, totlen);
totlen += krb_encode_application_tag(s, krb_tgsreq->type, totlen);
totlen += krb_encode_recordmark(s, totlen);
/* READY SEND */
krb_tcp_send(krb_ctx, s->p, totlen);
/* save stuff */
krb_ctx->nonce = krb_tgsreq->req_body.nonce;
xfree(krb_ctx->sname);
krb_ctx->sname = xstrdup(krb_tgsreq->req_body.sname);
krb_ctx->ctime = get_local_time(krb_tgsreq->req_body.from);
krb_ctx->state = KRB_TGSREQ_OK;
/* clean up */
freerdp_blob_free(krb_auth->cksum);
xfree(krb_auth->cksum);
xfree(krb_auth);
krb_free_tgsreq(krb_tgsreq);
xfree(krb_tgsreq);
stream_free(sapreq);
stream_free(s);
}
void krb_asreq_send(KRB_CONTEXT* krb_ctx, uint8 errcode)
{
KrbASREQ* krb_asreq;
PAData** pa_data;
KrbENCData enc_data;
KrbENCKey* enckey;
STREAM* s;
STREAM* paenc;
rdpBlob msg;
rdpBlob* encmsg;
uint32 curlen, totlen, pai;
uint8 *bm;
bm = NULL;
totlen = pai = 0;
krb_asreq = krb_asreq_new(krb_ctx, errcode);
pa_data = krb_asreq->padata;
enckey = NULL;
s = stream_new(2048);
paenc = stream_new(100);
//Begin write asn1 data reversely into stream
stream_seek(s, 1024);
stream_seek(paenc, 99);
/* KDC-REQ-BODY (TAG 4) */
totlen += krb_encode_req_body(s, &(krb_asreq->req_body), krb_asreq->type);
totlen += krb_encode_contextual_tag(s, 4, totlen);
/* padata = PA-ENC-TIMESTAMP */
if(errcode != 0)
{
freerdp_blob_alloc(&msg, 21);
memcpy(msg.data, "\x30\x13\xa0\x11\x18\x0f", 6); // PA-ENC-TS-ENC without optional pausec
memcpy(((uint8*) msg.data) + 6, krb_asreq->req_body.from, 15);
enckey = string2key(&(krb_ctx->passwd), krb_ctx->enctype);
encmsg = crypto_kdcmsg_encrypt(&msg, enckey, 1); //RFC4757 section 3 for msgtype (T=1)
enc_data.enctype = enckey->enctype;
enc_data.kvno = -1;
enc_data.encblob.data = encmsg->data;
enc_data.encblob.length = encmsg->length;
curlen = krb_encode_encrypted_data(paenc, &enc_data);
freerdp_blob_free(&msg);
msg.data = paenc->p;
msg.length = curlen;
/* padata = PA-ENC-TIMESTAMP */
(*(pa_data + pai))->type = 2;
(*(pa_data + pai))->value = msg;
pai++;
freerdp_blob_free(encmsg);
xfree(encmsg);
}
freerdp_blob_alloc(&msg, 7);
memcpy(msg.data, "\x30\x05\xa0\03\x01\x01", 6); // asn1 data
*((uint8*)msg.data + 6) = krb_asreq->pa_pac_request;
/* padata = PA-PAC-REQUEST */
(*(pa_data + pai))->type = 128;
(*(pa_data + pai))->value = msg;
*(pa_data + ++pai) = NULL;
/* padata (TAG 3) */
curlen = krb_encode_padata(s, pa_data);
totlen += curlen + krb_encode_contextual_tag(s, 3, curlen);
/* MSGTYPE = AS-REQ (TAG 2) */
totlen += krb_encode_uint8(s, 2, krb_asreq->type);
/* KERBEROS PROTOCOL VERSION NO (TAG 1)*/
totlen += krb_encode_uint8(s, 1, krb_asreq->pvno);
totlen += krb_encode_sequence_tag(s, totlen);
totlen += krb_encode_application_tag(s, krb_asreq->type, totlen);
totlen += krb_encode_recordmark(s, totlen);
/* READY SEND */
krb_tcp_send(krb_ctx, s->p, totlen);
/* save stuff */
krb_ctx->askey = enckey;
krb_ctx->nonce = krb_asreq->req_body.nonce;
xfree(krb_ctx->sname);
krb_ctx->sname = xstrdup(krb_asreq->req_body.sname);
krb_ctx->ctime = get_local_time(krb_asreq->req_body.from);
krb_ctx->state = KRB_ASREQ_OK;
/* clean up */
freerdp_blob_free(&msg);
stream_free(s);
stream_free(paenc);
krb_free_asreq(krb_asreq);
xfree(krb_asreq);
}
time_t get_clock_skew(char* str)
{
time_t ctime;
ctime = time(NULL);
return (get_local_time(str) - ctime);
}
void win_progname_draw_infor(void)
{
UINT16 group_name[MAX_SERVICE_NAME_LENGTH + 1 + 10];
UINT8 group_type,av_mode;
UINT16 cur_channel;
P_NODE p_node;
S_NODE s_node;
// T_NODE t_node;
char string[100];
char prog_name[MAX_SERVICE_NAME_LENGTH + 1];
INT32 ret,len;
UINT32 i,j;
BITMAP* bmp;
TEXT_FIELD* txt;
UINT16 icon;
date_time dt;
prog_txt_t* p_prog_txt;
prog_bmp_t* p_prog_bmp;
eit_event_info_t *pe=NULL,*fe=NULL;
UINT8 *s1=NULL,*s2=NULL;
INT32 strlen;
struct ACTIVE_SERVICE_INFO service;
struct t_ttx_lang *ttx_lang_list;
UINT8 ttx_lang_num;
struct t_subt_lang* sub_lang_list;
UINT8 sub_lang_num;
bmp = &prog_bmp;
txt = &prog_text;
UINT32 fav_mask;
fav_mask = 0;
for(i=0;i<MAX_FAVGROUP_NUM;i++)
fav_mask |= (0x01<<i);
av_mode = sys_data_get_cur_chan_mode();
cur_channel = sys_data_get_cur_group_cur_mode_channel();
ret = get_prog_at(cur_channel,&p_node);
get_sat_by_id(p_node.sat_id, &s_node);
get_cur_group_name((char*)group_name,&group_type);
get_local_time(&dt);
/*
#ifdef _EPG_MULTI_SERVICE
#ifdef EPG_FAST_PARSE
epg_fast_pasrse_set(FALSE,NULL,NULL);
#endif
get_tp_by_id(p_node.tp_id, &t_node);
api_epg_parse(p_node.tp_id, t_node.network_id, t_node.t_s_id, p_node.prog_number, epg_type_pf);
struct active_service_t service;
service.tp_id = p_node.tp_id;
service.orig_network_id = t_node.network_id;
service.ts_id = t_node.t_s_id;
service.service_id = p_node.prog_number;
api_epg_set_active_service(&service, 1);
api_epg_parse(p_node.tp_id, t_node.network_id, t_node.t_s_id, p_node.prog_number, epg_type_pf);
#endif
*/
service.tp_id = p_node.tp_id;
service.service_id = p_node.prog_number;
epg_set_active_service(&service, 1);
/*current next epg info */
pe=epg_get_cur_service_event((INT32)cur_channel, PRESENT_EVENT, NULL,NULL,NULL, /*event_update*/TRUE);
fe=epg_get_cur_service_event((INT32)cur_channel, FOLLOWING_EVENT, NULL,NULL,NULL, event_update);
if(event_update==FALSE)
{
if(pe==NULL || fe==NULL)
{
event_update = TRUE;
}
}
else
{
if(pe!=NULL && fe!=NULL)
{
event_update = FALSE;
}
}
s1=epg_get_event_name(pe, &len);
// s1=(UINT8*)epg_get_event_name(pe, present_name, 32);
s2=epg_get_event_name(fe, &len);
// s2=(UINT8*)epg_get_event_name(fe, following_name, 32);
TTXEng_GetInitLang(&ttx_lang_list, &ttx_lang_num);
subt_get_language(&sub_lang_list ,&sub_lang_num);
if(sub_lang_num == 0)
TTXEng_GetSubtLang(&ttx_lang_list,&sub_lang_num);
for(i=0;i<PROG_BMP_NUM;i++)
{
p_prog_bmp = &prog_bmps[i];
icon = INVALID_ID;
switch(p_prog_bmp->bmp_type)
{
case PROG_BMP_STATIC:
icon = prog_bmps[i].icon;
break;
#ifndef MODIFY_FOR_EGYPT_CUSTOMER
case PROG_BMP_AV_TYPE:
if(av_mode==TV_CHAN)
icon = IM_INFO_BAR_TV;
else
icon = IM_INFO_BAR_RADIO;
break;
#endif
case PROG_BMP_EPG:
if( (s1||s2) )
icon = prog_bmps[i].icon;
break;
case PROG_BMP_TTX:
if(ttx_lang_num>0)
icon = prog_bmps[i].icon;
break;
case PROG_BMP_SUBT:
if(sub_lang_num>0)
icon = prog_bmps[i].icon;
break;
case PROG_BMP_LOCK:
if(p_node.lock_flag)
icon = prog_bmps[i].icon;
break;
case PROG_BMP_FAV:
if(p_node.fav_group[0] & fav_mask)
icon = prog_bmps[i].icon;
break;
case PROG_BMP_CA:
{
#if 0
BOOL b,bFlag;
INT8 level,quality,lock;
signal_lock_status lock_flag;
signal_scramble_status scramble_flag;
signal_lnbshort_status lnbshort_flag;
signal_parentlock_status parrentlock_flag;
bFlag = GetSignalStatus(&lock_flag, &scramble_flag,&lnbshort_flag,&parrentlock_flag);
if(bFlag && lock_flag== SIGNAL_STATUS_LOCK
&& lnbshort_flag==SIGNAL_STATUS_LNBNORMAL
&& parrentlock_flag==SIGNAL_STATUS_PARENT_UNLOCK
&& scramble_flag == SIGNAL_STATUS_SCRAMBLED)
icon = prog_bmps[i].icon;
#else
if(p_node.ca_mode)
icon = prog_bmps[i].icon;
#endif
}
break;
default:
break;
}
OSD_SetBitmapContent(bmp, icon);
OSD_SetRect(&bmp->head.frame, p_prog_bmp->left, p_prog_bmp->top, p_prog_bmp->width,p_prog_bmp->height);
OSD_DrawObject( (OBJECT_HEAD*) bmp, C_UPDATE_ALL);
}
for(i=0;i<PROG_TXT_NUM;i++)
{
p_prog_txt = &prog_txts[i];
string[0] = '\0';
switch(p_prog_txt->txt_type)
{
case PROG_TXT_PROG_NAME:
#ifndef DB_USE_UNICODE_STRING
STRCPY(prog_name,p_node.service_name);
for(j=0;j<STRLEN(prog_name);j++)
if(prog_name[j] >= 0x80)
{
prog_name[j] = '\0';
break;
}
if(p_node.ca_mode==0)
sprintf(string,"%s(%s)",prog_name,s_node.sat_name);
else
sprintf(string,"$%s(%s)",prog_name,s_node.sat_name);
#else
if(p_node.ca_mode==0)
STRCPY(string,"");
else
STRCPY(string,"$");
ComAscStr2Uni(string,len_display_str);
strlen = ComUniStrLen( len_display_str);
//strcpy_uni(&len_display_str[strlen],p_node.service_name);
ComUniStrCopyChar((UINT8 * )&len_display_str[strlen],p_node.service_name);
strlen = ComUniStrLen( len_display_str);
ComAscStr2Uni("(",&len_display_str[strlen]);
strlen = ComUniStrLen( len_display_str);
ComUniStrCopyChar((UINT8 * )&len_display_str[strlen],s_node.sat_name);
strlen = ComUniStrLen( len_display_str);
ComAscStr2Uni(")",&len_display_str[strlen]);
#endif
break;
case PROG_TXT_DATE:
sprintf(string,"%02d/%02d",dt.month,dt.day);
ComAscStr2Uni(string, (UINT16 *)len_display_str);
break;
case PROG_TXT_TIME:
sprintf(string,"%02d:%02d",dt.hour,dt.min);
ComAscStr2Uni(string, (UINT16 *)len_display_str);
break;
case PROG_TXT_PROG_NUM:
sprintf(string,"%04d",cur_channel + 1);
ComAscStr2Uni(string, (UINT16 *)len_display_str);
break;
case PROG_TXT_EPG_NOW:
if (s1 )
{
sprintf(string,"Now: ");
ComAscStr2Uni(string, (UINT16 *)len_display_str);
len =ComUniStrLen(len_display_str);
ComUniStrCopyChar((UINT8*)&len_display_str[len],s1);
}
else
{
OSD_SetTextFieldStrPoint(txt,NULL);
OSD_SetTextFieldContent(txt,STRING_ID,RS_EPG_NO_INFORMATION);
}
break;
case PROG_TXT_EPG_NEXT:
if (s2)
{
sprintf(string,"Next: ");
ComAscStr2Uni(string, (UINT16 *)len_display_str);
len =ComUniStrLen(len_display_str);
ComUniStrCopyChar((UINT8*)&len_display_str[len],s2);
}
else
{
sprintf(string," ");
ComAscStr2Uni(string, (UINT16 *)len_display_str);
}
break;
case PROG_TXT_PROG_GROUP:
#ifndef DB_USE_UNICODE_STRING
sprintf(string,"%s",group_name);
#else
ComUniStrCopy(len_display_str, group_name);
#endif
break;
default:
;
}
#ifndef DB_USE_UNICODE_STRING
ComAscStr2Uni(string, (UINT16 *)len_display_str);
#else
/*
if(p_prog_txt->txt_type != PROG_TXT_PROG_NAME
&& p_prog_txt->txt_type != PROG_TXT_PROG_GROUP
&&p_prog_txt->txt_type != PROG_TXT_EPG_NOW
&&p_prog_txt->txt_type != PROG_TXT_EPG_NEXT)
ComAscStr2Uni(string, (UINT16 *)len_display_str);
*/
if(p_prog_txt->txt_type == PROG_TXT_PROG_NUM)
txt->head.bFont = 2;
else
txt->head.bFont = 0;
#endif
OSD_SetRect(&txt->head.frame, p_prog_txt->left, p_prog_txt->top, p_prog_txt->width,p_prog_txt->height);
//txt->pText = (UINT8*)len_display_str;
txt->head.style.bShowIdx = p_prog_txt->shidx;
OSD_DrawObject( (OBJECT_HEAD *)txt, C_UPDATE_ALL);
OSD_SetTextFieldContent(txt,STRING_ID,0);
OSD_SetTextFieldStrPoint(txt,len_display_str);
}
#ifdef MODIFY_FOR_EGYPT_CUSTOMER
progname_signal_refresh(TRUE);
#endif
}
void win_time_right_key(POBJECT_HEAD pObj,UINT8 id)
{
INT32 hoffset, moffset;
SYSTEM_DATA* p_sys_data=sys_data_get();
switch(id)
{
case MENU_TIMESET_GMT_ENABLE:
p_sys_data->local_time.buseGMT=1-p_sys_data->local_time.buseGMT;
win_time_set_GMT_enable_string(p_sys_data->local_time.buseGMT);
OSD_TrackObject(pObj,C_UPDATE_ALL);
win_time_switch_GMT_Type(p_sys_data->local_time.buseGMT);
if(p_sys_data->local_time.buseGMT)
{
get_UTC(&win_time_local_time);
set_STC_time(&win_time_local_time);
set_time_data();
set_time_clock();
}
else
{
p_sys_data->local_time.GMToffset_count = 23;
win_time_set_GMT_Offset_string(p_sys_data->local_time.GMToffset_count);
p_sys_data->local_time.SummerTime=0;
enable_summer_time(0);
win_time_set_Summer_string(p_sys_data->local_time.SummerTime);
}
OSD_DrawObject((POBJECT_HEAD )&time_item_con2,C_UPDATE_ALL);
OSD_DrawObject((POBJECT_HEAD )&time_item_con3,C_UPDATE_ALL);
OSD_DrawObject((POBJECT_HEAD )&time_item_con4,C_UPDATE_ALL);
OSD_DrawObject((POBJECT_HEAD )&time_item_con5,C_UPDATE_ALL);
win_time_set_time_zone_citys(TRUE);
break;
case MENU_TIMESET_SUMMER:
p_sys_data->local_time.SummerTime=1-p_sys_data->local_time.SummerTime;
win_time_set_Summer_string(p_sys_data->local_time.SummerTime);
OSD_TrackObject(pObj,C_UPDATE_ALL);
enable_summer_time(p_sys_data->local_time.buseGMT && p_sys_data->local_time.SummerTime);
get_local_time(&win_time_local_time);
set_time_data();
set_time_clock();
OSD_DrawObject((POBJECT_HEAD )&time_item_con4,C_UPDATE_ALL);
OSD_DrawObject((POBJECT_HEAD )&time_item_con5,C_UPDATE_ALL);
break;
case MENU_TIMESET_DISPLAY:
p_sys_data->local_time.TimeDisplay=1-p_sys_data->local_time.TimeDisplay;
win_time_set_Display_string(p_sys_data->local_time.TimeDisplay);
OSD_TrackObject(pObj,C_UPDATE_ALL);
break;
case MENU_TIMESET_GMT_OFFESET:
if(p_sys_data->local_time.GMToffset_count==47)
{
p_sys_data->local_time.GMToffset_count=0;
}
else
{
p_sys_data->local_time.GMToffset_count++;
}
win_time_set_GMT_Offset_string(p_sys_data->local_time.GMToffset_count);
OSD_TrackObject(pObj,C_UPDATE_ALL);
sys_data_gmtoffset_2_hmoffset(&hoffset, &moffset);
set_STC_offset( hoffset, moffset, 0);
get_local_time(&win_time_local_time);
set_time_data();
set_time_clock();
OSD_DrawObject((POBJECT_HEAD )&time_item_con4,C_UPDATE_ALL);
OSD_DrawObject((POBJECT_HEAD )&time_item_con5,C_UPDATE_ALL);
win_time_set_time_zone_citys(TRUE);
break;
}
}
void cti_chnchg_function()
{
UINT16 chn_idx=0xffff;
date_time local_time;
CTI_CHN_CHG_CONTENT chnchg_data;
UINT8 save;
BOOL need_change = TRUE,info_changed = FALSE;
win_popup_choice_t sel;
UINT16 string[CHANNEL_JUMP_STR_LEN_MAX/2+1];
INT sec = 0;
if(pre_channel_index!=sys_data_get_cur_group_cur_mode_channel())//换台了
{
cti_chnchg_para_reset();
}
if(!get_cti_chnchg_flg())
{
return;
}
MEMSET(&local_time,0,sizeof(date_time));
get_local_time(&local_time);
MEMSET(&chnchg_data,0,sizeof(CTI_CHN_CHG_CONTENT));
get_cti_chnchg_data(&chnchg_data);
//显示内容有没有变化
if(MEMCMP(pre_info,chnchg_data.pString,sizeof(chnchg_data.pString))==0)
{
info_changed = FALSE;
}
else
{
info_changed = TRUE;
}
chn_idx=GetPlayChannelID(chnchg_data.bType,chnchg_data.wPart1,
chnchg_data.wPart2,chnchg_data.wPart3,chnchg_data.wPart4);
if((chnchg_data.bStatus==0)
||(chnchg_data.bStatus==2))//立即跳转
{
set_cti_chnchg_flg(FALSE);
}
else//时间跳转
{
if(api_compare_day_time_ext(&(chnchg_data.stStartTime),&local_time)>=0) //跳转时间没有到
{
need_change = FALSE;
}
else if(api_compare_day_time_ext(&(chnchg_data.stEndTime),&local_time)>=0) //正常跳转
{
sec = cti_mktime(&(chnchg_data.stEndTime),&local_time);
}
else//控制时间已过
{
need_change = FALSE;
set_cti_chnchg_flg(FALSE);
return;
}
}
if((chn_idx!=0xffff)
&&(chn_idx!=sys_data_get_cur_group_cur_mode_channel())
&&need_change)
{
if(chnchg_data.bStatus==0)//强制立即跳转
{
BackToFullScrPlay();
win_compopup_init ( WIN_POPUP_TYPE_SMSG );
win_compopup_set_frame ( 100, 140, 400, 120);
//win_compopup_set_frame(100, 180, 400, 80);
win_compopup_set_msg_ext(NULL,NULL, RS_CTI_CHANNEL_JUMP);
win_compopup_open_ext ( &save );
osal_task_sleep(3000);
win_compopup_close();
}
else if(chnchg_data.bStatus==1)//强制时间跳转
{
if(!info_showed)
{
BackToFullScrPlay();
win_compopup_init ( WIN_POPUP_TYPE_SMSG );
win_compopup_set_frame ( 100, 140, 400, 120);
//win_compopup_set_frame(100, 180, 400, 80);
win_compopup_set_msg_ext(NULL,NULL, RS_CTI_CHANNEL_JUMP);
win_compopup_open_ext ( &save );
osal_task_sleep(3000);
win_compopup_close();
info_showed = TRUE;
}
}
else if(chnchg_data.bStatus==2)//用户选择立即跳转
{
if((sys_data_get_cur_group_cur_mode_channel()==chn_idx_sel_no)
&&(!info_changed))
{
return;
}
else
{
BackToFullScrPlay();
MEMSET(string,0,sizeof(string));
MEMSET(pre_info,0,sizeof(pre_info));
#ifdef GB2312_SUPPORT
convert_gb2312_to_unicode(chnchg_data.pString,
sizeof(chnchg_data.pString),string, CHANNEL_JUMP_STR_LEN_MAX/2);
#else
dvb_to_unicode(chnchg_data.pString,
sizeof(chnchg_data.pString),string, CHANNEL_JUMP_STR_LEN_MAX/2, 0);
#endif
MEMCPY(pre_info,chnchg_data.pString,sizeof(chnchg_data.pString));
win_compopup_init ( WIN_POPUP_TYPE_OKNO);
//win_compopup_set_frame ( 100, 120, 400, 160);
win_compopup_set_frame ( 100, 100, 400, 160);
win_compopup_set_msg_ext(NULL, string, 0);
win_compopup_set_default_choice(WIN_POP_CHOICE_YES);
sel = win_compopup_open_ext_timeout(&save, 5);
if (sel == WIN_POP_CHOICE_NO)
{
chn_idx_sel_no = sys_data_get_cur_group_cur_mode_channel();
return;//do not change
}
//choice yes,so change channel
}
}
else if(chnchg_data.bStatus==3)//用户选择按时间跳转
{
if((!info_showed)||info_changed)//没有显示过或者字符变化了
{
BackToFullScrPlay();
MEMSET(string,0,sizeof(string));
MEMSET(pre_info,0,sizeof(pre_info));
#ifdef GB2312_SUPPORT
convert_gb2312_to_unicode(chnchg_data.pString,
sizeof(chnchg_data.pString),string, CHANNEL_JUMP_STR_LEN_MAX/2);
#else
dvb_to_unicode(chnchg_data.pString,
sizeof(chnchg_data.pString),string, CHANNEL_JUMP_STR_LEN_MAX/2, 0);
#endif
MEMCPY(pre_info,chnchg_data.pString,sizeof(chnchg_data.pString));
win_compopup_init ( WIN_POPUP_TYPE_OKNO);
win_compopup_set_frame ( 100, 100, 400, 160);
win_compopup_set_msg_ext(NULL, string, 0);
win_compopup_set_default_choice(WIN_POP_CHOICE_YES);
sel = win_compopup_open_ext_timeout(&save, sec);
choiced_yes = FALSE;
info_showed = TRUE;
if ((sel == WIN_POP_CHOICE_NO) || (sel == WIN_POP_CHOICE_TIMEOUT))
{
return;//do not change
}
choiced_yes = TRUE;
}
else if(choiced_yes==TRUE)//用户选择yes，则继续判断是否需要跳转
{
}
else
{
return;//提示过，不再提醒，也不换台
}
}
api_play_channel(chn_idx, TRUE, TRUE, FALSE);
}
}