int main(){
int i=0;
char c;
printf("Enter an abitrarily long string, ending with carriage return > ");
scan_data(&c);
while (c != '\n'){
add(&i, &c);
scan_data(&c);
}
i = (i % 64)+32;
printf("Check sum is %c\n", i);
return 0;
}
void edit_nth(list *start) // edit nth item
{
int n = 0;
int i = 1;
int val = 0;
if (!error(start)) return;
cout << " # input n>1 and n < size_list: ";
cin >> n;
while (start->next_adres)
{
if (n == i)
{
val = scan_data();
start->data = val;
break;
}
start = start->next_adres;
i++;
} // while
if (!val)
{
cout << " # n incorrectly , try again" << endl;
_getch();
}
}
static int dev_scan(uint32_t seq, char *cmd, int fd, char *buf, ssize_t size)
{
int ret = -1;
/*
* FIXME: There are too many stuff here! Maybe we should
* split this into smaller per-table calls.
*/
#if 0
struct dvb_open_descriptor *open_dev;
int uid;
ret = scan_data(buf, size, "%i%i", &uid);
if (ret < 0)
goto error;
open_dev = get_open_dev(uid);
if (!open_dev) {
ret = -1;
err("Can't find uid to scan");
goto error;
}
ret = dvb_scan(foo);
error:
return send_data(fd, "%i%s%i", seq, cmd, ret);
#else
return send_data(fd, "%i%s%i", seq, cmd, ret);
#endif
}
static int dev_dmx_set_section_filter(uint32_t seq, char *cmd, int fd,
char *buf, ssize_t size)
{
struct dvb_open_descriptor *open_dev;
int uid, ret, pid, filtsize, flags;
unsigned char filter[17], mask[17], mode[17];
ret = scan_data(buf, size, "%i%i%i%s%s%s%i",
&uid, &pid, &filtsize, filter, mask, mode, &flags);
if (ret < 0)
goto error;
open_dev = get_open_dev(uid);
if (!open_dev) {
ret = -1;
err("Can't find uid to set section filter");
goto error;
}
ret = dvb_dev_dmx_set_section_filter(open_dev, pid, filtsize, filter,
mask, mode, flags);
error:
return send_data(fd, "%i%s%i", seq, cmd, ret);
}
void add(list **start, list **end) // add some new item in the end list
{
int val;
int fl = 0;
cout << " ###############################################################" << endl;
cout << " # ADD NEW ITEM IN THE LIST #" << endl;
cout << " # FOR EXIT PRESS 0 #" << endl;
cout << " ###############################################################" << endl;
val = scan_data();
if (*end == NULL)
{
first_item(start, end);
}
while (val)
{
add_end(end, val);
val = scan_data();
} // while
}
void edit_end(list *start) // edit end item
{
int val = 0;
list *buff=NULL;
if (!error(start)) return;
do
{
buff = start;
start = start->next_adres;
} while (start->next_adres);
buff->data = scan_data();
}
void scanner::run()
{
switch(_is_file)
{
case true:
scan_file();
break;
case false:
scan_data();
break;
}
}
void practice()
{
int get,i,count=0,win=0,lose=0;
srand(time(0));
shouming();
while(1){
get=scan_data();
if(get==0)
break;
i=computer();
win_or_lose(get,i,&win,&lose,&count);
}
printf("胜利：%d盘\t失败：%d盘\t总盘数：%d盘\n",win,lose,count);
}
static int dev_set_sys(uint32_t seq, char *cmd, int fd,
char *buf, ssize_t size)
{
struct dvb_v5_fe_parms_priv *parms = (void *)dvb->fe_parms;
struct dvb_v5_fe_parms *p = (void *)parms;
int sys = 0, ret;
ret = scan_data(buf, size, "%i", &sys);
if (ret < 0)
goto error;
ret = __dvb_set_sys(p, sys);
error:
return send_data(fd, "%i%s%i", seq, cmd, ret);
}
static int dev_find(uint32_t seq, char *cmd, int fd, char *buf, ssize_t size)
{
int enable_monitor = 0, ret;
dvb_dev_change_t handler = NULL;
ret = scan_data(buf, size, "%i", &enable_monitor);
if (ret < 0)
goto error;
if (enable_monitor)
handler = &dev_change_monitor;
ret = dvb_dev_find(dvb, handler, NULL);
error:
return send_data(fd, "%i%s%i", seq, cmd, ret);
}
main()
{
P2=0xff; //make output port
SerialInput();
InitLCD();
EA=1;
ES=1;
while(1)
{
ClearLCDScreen();
while(ps2_clk==1);
keyval=scan_data();
WriteDataToLCD(keyval);
encrypt_data=keyval+3
35SerialTransmit();
delayms(100);
}
}
void duizhanmoshi(struct user *p)
{
int get,i,count=0,win=0,lose=0;
srand(time(0));
shouming();
while((win!=2)&&(lose!=2)){
get=scan_data();
i=computer();
win_or_lose(get,i,&win,&lose,&count);
}
printf("胜利：%d盘\t失败：%d盘\t总盘数：%d盘\n",win,lose,count);
if(win==2) {printf("You win! \n");}
else {printf("Sorry,you lose!!!\n");}
printf("大侠，请留名:");
getchar();
gets(stu[N].name);
stu[N].win=win;
stu[N].count=count;
save_data(&stu[N]);
}
static int dev_seek_by_adapter(uint32_t seq, char *cmd, int fd,
char *buf, ssize_t size)
{
struct dvb_dev_list *dev;
int adapter, num, type, ret;
ret = scan_data(buf, size, "%i%i%i", &adapter, &num, &type);
if (ret < 0)
goto error;
dev = dvb_dev_seek_by_adapter(dvb, adapter, num, type);
if (!dev)
goto error;
return send_data(fd, "%i%s%i%s%s%s%i%s%s%s%s%s", seq, cmd, ret,
dev->syspath, dev->path, dev->sysname, dev->dvb_type,
dev->bus_addr, dev->bus_id, dev->manufacturer,
dev->product, dev->serial);
error:
return send_data(fd, "%i%s%i", seq, cmd, ret);
}
// Initialize touch input
void touch_init(uint32_t channel_mask)
{
// Turn on clock gating for TSI and configure touch input
SIM_SCGC5 |= SIM_SCGC5_TSI_MASK;
TSI0_GENCS |= (TSI_GENCS_ESOR_MASK // Enable end of scan interrupt
| TSI_GENCS_MODE(0) // Capactive sensing
| TSI_GENCS_REFCHRG(4) // Reference charge 4 uA
| TSI_GENCS_DVOLT(0) // Voltage rails
| TSI_GENCS_EXTCHRG(7) // External osc charge
| TSI_GENCS_PS(4) // Prescalar divide by 4
| TSI_GENCS_NSCN(11) // Scans per electrode
| TSI_GENCS_TSIIEN_MASK // Input interrupt enable
| TSI_GENCS_STPE_MASK // Enable in STOP mode
);
TSI0_GENCS |= TSI_GENCS_TSIEN_MASK;
// Enable touch I/O pins for Freedom board, and configure
// the scan sequence
PORTB_PCR16 = PORT_PCR_MUX(0); // PTB16 as touch channel 9
PORTB_PCR17 = PORT_PCR_MUX(0); // PTB17 as touch channel 10
// Read initial (baseline) values for each enabled channel
int i, first_channel = 0;
enable_mask = channel_mask;
for(i=15; i>=0; i--) {
if((1 << i) & enable_mask) {
scan_start(i);
while(!(TSI0_GENCS & TSI_GENCS_EOSF_MASK)) // Wait until done
;
base_counts[i] = scan_data();
first_channel = i;
}
}
// Enable TSI interrupts and start the first scan
enable_irq(INT_TSI0);
scan_start(first_channel);
}
static int dev_get_dev_info(uint32_t seq, char *cmd, int fd,
char *buf, ssize_t size)
{
struct dvb_dev_list *dev;
char sysname[REMOTE_BUF_SIZE];
int ret;
ret = scan_data(buf, size, "%s", sysname);
if (ret < 0)
goto error;
dev = dvb_get_dev_info(dvb, sysname);
if (!dev)
goto error;
return send_data(fd, "%i%s%i%s%s%s%i%s%s%s%s%s", seq, cmd, ret,
dev->syspath, dev->path, dev->sysname, dev->dvb_type,
dev->bus_addr, dev->bus_id, dev->manufacturer,
dev->product, dev->serial);
error:
return send_data(fd, "%i%s%i", seq, cmd, ret);
}
static int dev_close(uint32_t seq, char *cmd, int fd, char *buf, ssize_t size)
{
struct dvb_open_descriptor *open_dev;
int uid, ret, i;
ret = scan_data(buf, size, "%i", &uid);
if (ret < 0)
goto error;
open_dev = get_open_dev(uid);
if (!open_dev) {
err("Can't find uid to close");
ret = -1;
goto error;
}
/* Delete fd from the opened array */
pthread_mutex_lock(&dvb_read_mutex);
for (i = 0; i < numfds; i++) {
if (fds[i].fd != open_dev->fd)
continue;
if (i < numfds - 1)
memmove(&fds[i], &fds[i + 1],
sizeof(*fds)*(numfds - i - 1));
numfds--;
break;
}
pthread_mutex_unlock(&dvb_read_mutex);
if (read_id && !numfds) {
pthread_cancel(read_id);
read_id = 0;
}
dvb_dev_close(open_dev);
destroy_open_dev(uid);
error:
return send_data(fd, "%i%s%i", seq, cmd, ret);
}
static int dev_dmx_get_pmt_pid(uint32_t seq, char *cmd, int fd,
char *buf, ssize_t size)
{
struct dvb_open_descriptor *open_dev;
int uid, ret, sid;
ret = scan_data(buf, size, "%i%i", &uid, &sid);
if (ret < 0)
goto error;
open_dev = get_open_dev(uid);
if (!open_dev) {
ret = -1;
err("Can't find uid to get PMT PID");
goto error;
}
ret = dvb_dev_dmx_get_pmt_pid(open_dev, sid);
error:
return send_data(fd, "%i%s%i", seq, cmd, ret);
}
static int dev_set_bufsize(uint32_t seq, char *cmd, int fd,
char *buf, ssize_t size)
{
struct dvb_open_descriptor *open_dev;
int uid, ret, bufsize;
ret = scan_data(buf, size, "%i%i", &uid, &bufsize);
if (ret < 0)
goto error;
open_dev = get_open_dev(uid);
if (!open_dev) {
ret = -1;
err("Can't find uid to stop");
goto error;
}
dvb_dev_set_bufsize(open_dev, bufsize);
error:
return send_data(fd, "%i%s%i", seq, cmd, ret);
}
static int dev_dmx_set_pesfilter(uint32_t seq, char *cmd, int fd,
char *buf, ssize_t size)
{
struct dvb_open_descriptor *open_dev;
int uid, ret, pid, type, output, bufsize;
ret = scan_data(buf, size, "%i%i%i%i%i",
&uid, &pid, &type, &output, &bufsize);
if (ret < 0)
goto error;
open_dev = get_open_dev(uid);
if (!open_dev) {
ret = -1;
err("Can't find uid to set pesfilter");
goto error;
}
ret = dvb_dev_dmx_set_pesfilter(open_dev, pid, type, output, bufsize);
error:
return send_data(fd, "%i%s%i", seq, cmd, ret);
}
static int dev_open(uint32_t seq, char *cmd, int fd, char *buf, ssize_t size)
{
struct dvb_open_descriptor *open_dev;
struct dvb_dev_list *dev;
struct dvb_descriptors *desc, **p;
int ret, flags, uid;
char sysname[REMOTE_BUF_SIZE];
desc = calloc(1, sizeof(*desc));
if (!desc) {
local_perror("calloc");
ret = -ENOMEM;
goto error;
}
ret = scan_data(buf, size, "%s%i", sysname, &flags);
if (ret < 0) {
free(desc);
goto error;
}
/*
* Discard requests for O_NONBLOCK, as the daemon will use threads
* to handle unblocked reads.
*/
flags &= ~O_NONBLOCK;
open_dev = dvb_dev_open(dvb, sysname, flags);
if (!open_dev) {
ret = -errno;
free(desc);
goto error;
}
if (verbose)
dbg("open dev handler for %s: %p with uid#%d", sysname, open_dev, open_dev->fd);
dev = open_dev->dev;
if (dev->dvb_type == DVB_DEVICE_DEMUX ||
dev->dvb_type == DVB_DEVICE_DVR) {
pthread_mutex_lock(&dvb_read_mutex);
fds[numfds].fd = open_dev->fd;
fds[numfds].events = POLLIN | POLLPRI;
numfds++;
pthread_mutex_unlock(&dvb_read_mutex);
}
if (!read_id) {
ret = pthread_create(&read_id, NULL, read_data, NULL);
if (ret < 0) {
local_perror("pthread_create");
pthread_mutex_unlock(&msg_mutex);
free(desc);
return -1;
}
}
pthread_mutex_unlock(&msg_mutex);
uid = open_dev->fd;
desc->uid = uid;
desc->open_dev = open_dev;
/* Add element to the desc_root tree */
p = tsearch(desc, &desc_root, dvb_desc_compare);
if (!p) {
local_perror("tsearch");
uid = 0;
}
if (*p != desc) {
err("uid %d was already opened!");
}
pthread_mutex_unlock(&msg_mutex);
ret = uid;
error:
return send_data(fd, "%i%s%i", seq, cmd, ret);
}
while(!(TSI0_GENCS & TSI_GENCS_EOSF_MASK)) // Wait until done
;
base_counts[i] = scan_data();
first_channel = i;
}
}
// Enable TSI interrupts and start the first scan
enable_irq(INT_TSI0);
scan_start(first_channel);
}
// Touch input interrupt handler
void TSI0_IRQHandler() __attribute__((interrupt("IRQ")));
void TSI0_IRQHandler(void)
{
// Save data for channel
uint32_t channel = (TSI0_DATA & TSI_DATA_TSICH_MASK) >> TSI_DATA_TSICH_SHIFT;
raw_counts[channel] = scan_data();
// Start a new scan on next enabled channel
for(;;) {
channel = (channel + 1) % NCHANNELS;
if ((1 << channel) & enable_mask) {
scan_start(channel);
return;
}
}
}
static int dev_set_parms(uint32_t seq, char *cmd, int fd,
char *buf, ssize_t size)
{
struct dvb_v5_fe_parms_priv *parms = (void *)dvb->fe_parms;
struct dvb_v5_fe_parms *par = (void *)parms;
int ret, i;
char *p = buf;
const char *old_lnb = "";
char new_lnb[256];
if (verbose)
dbg("dev_set_parms called");
/* first the public params that aren't read only */
/* Get current LNB name */
if (par->lnb)
old_lnb = par->lnb->name;
ret = scan_data(p, size, "%i%i%s%i%i%i%i%s%s",
&par->abort, &par->lna, new_lnb,
&par->sat_number, &par->freq_bpf, &par->diseqc_wait,
&par->verbose, default_charset, output_charset);
if (ret < 0)
goto error;
p += ret;
size -= ret;
/* Now, the private ones */
ret = scan_data(p, size, "%i", &i);
if (ret < 0)
goto error;
parms->country = i;
p += ret;
size -= ret;
for (i = 0; i < parms->n_props; i++) {
ret = scan_data(p, size, "%i%i",
&parms->dvb_prop[i].cmd,
&parms->dvb_prop[i].u.data);
if (ret < 0)
goto error;
p += ret;
size -= ret;
}
if (!*new_lnb) {
par->lnb = NULL;
} else if (strcmp(old_lnb, new_lnb)) {
int lnb = dvb_sat_search_lnb(new_lnb);
if (lnb < 0) {
dvb_logerr("Invalid lnb: %s", new_lnb);
ret = -1;
goto error;
}
par->lnb = dvb_sat_get_lnb(lnb);
}
par->output_charset = output_charset;
par->default_charset = default_charset;
ret = __dvb_fe_set_parms(par);
error:
return send_data(fd, "%i%s%i", seq, cmd, ret);
}
static void *start_server(void *fd_pointer)
{
const struct method_types *method;
int fd = *(int *)fd_pointer, ret, flag = 1;
char buf[REMOTE_BUF_SIZE + 8], cmd[80], *p;
ssize_t size;
uint32_t seq;
int bufsize;
if (verbose)
dbg("Opening socket %d", fd);
/* Set a large buffer for read() to work better */
bufsize = REMOTE_BUF_SIZE;
setsockopt(fd, SOL_SOCKET, SO_SNDBUF,
(void *)&bufsize, (int)sizeof(bufsize));
/* Disable Naggle algorithm, as we want errors to be sent ASAP */
setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *) &flag, sizeof(int));
/* Command dispatcher */
do {
size = recv(fd, buf, 4, MSG_WAITALL);
if (size <= 0)
break;
size = (uint32_t)buf[0] << 24 | (uint32_t)buf[1] << 16 |
(uint32_t)buf[2] << 8 | (uint32_t)buf[3];
size = recv(fd, buf, size, MSG_WAITALL);
if (size <= 0)
break;
ret = scan_data(buf, size, "%i%s", &seq, cmd);
if (ret < 0) {
if (verbose)
dbg("message too short: %d", size);
send_data(fd, "%i%s%i%s", 0, "log", LOG_ERR,
"msg too short");
continue;
}
p = buf + ret;
size -= ret;
if (verbose)
dbg("received command: %i '%s'", seq, cmd);
if (size > buf + sizeof(buf) - p) {
if (verbose)
dbg("data length too big: %d", size);
send_data(fd, "%i%s%i%s", 0, "log", LOG_ERR,
"data length too big");
continue;
}
method = methods;
while (method->name) {
if (!strcmp(cmd, method->name)) {
if (dvb_fd > 0 || method->locks_dvb) {
ret = method->handler(seq, cmd,
fd, p, size);
if (ret < 0)
break;
if (method->locks_dvb)
dvb_fd = fd;
break;
}
send_data(fd, "%i%s%i%s", 0, "log", LOG_ERR,
"daemon busy");
break;
}
method++;
}
if (!method->name) {
if (verbose)
dbg("invalid command: %s", cmd);
send_data(fd, "%i%s%i%s", 0, "log", LOG_ERR,
"invalid command");
}
} while (1);
if (verbose)
dbg("Closing socket %d", fd);
close(fd);
if (read_id) {
pthread_cancel(read_id);
read_id = 0;
}
if (dvb_fd > 0)
close_all_devs();
return NULL;
}
