MbClientHandle
mb_client_register(int id, int is_bidi)
{
mbclient* client = get_client_by_id(id);
if (client == NULL) {
client = malloc(sizeof(mbclient));
if (client == NULL) {
return NULL;
}
memset(&(client->sock), 0, sizeof(struct sockaddr_un));
client->id = id;
client->pages = 0;
client->source_pages = 0;
client->fd = 0;
client->is_bidi = is_bidi ? 1 : 0;
if (client_register(client) < 0) {
free (client);
return NULL;
} else {
client->next = mb_default_client.next;
mb_default_client.next = client;
}
} else {
if (client->is_bidi != is_bidi)
client = NULL;
}
return client;
}
MbClientHandle
mb_client_register_source(int id, int pages)
{
mbclient* client = get_client_by_id(id);
if (client == NULL) {
client = malloc(sizeof(mbclient));
if (client == NULL) {
return NULL;
}
memset(&(client->sock), 0, sizeof(struct sockaddr_un));
client->id = id;
client->pages = pages;
client->source_pages = pages < 0 ? 0 : pages;
client->fd = 0;
client->is_bidi = 1;
if (client_register(client) < 0) {
free(client);
return NULL;
} else {
client->next = mb_default_client.next;
mb_default_client.next = client;
}
} else {
if (!(client->is_bidi != 1) ||
client->source_pages != (unsigned int)pages)
client = NULL;
}
return client;
}
int main(int argc, char*argv[]) {
if(argc < 3) {
fprintf(stderr, "usage: %s <ip> <command> \n", argv[0]);
return(0);
}
const char* ip = argv[1]; argc--;
const char* cmd = argv[2]; argc--;
rcp_connect(ip);
start_event_handler();
client_register(RCP_USER_LEVEL_SERVICE, "service", RCP_REGISTRATION_TYPE_NORMAL, RCP_ENCRYPTION_MODE_PLAIN);
if(strcmp(cmd, "UP") == 0) {
pelcod_move_up(PTZ_ADDRESS, 0x3f);
} else if(strcmp(cmd, "DOWN") == 0) {
pelcod_move_down(PTZ_ADDRESS, 0x3f);
} else if(strcmp(cmd, "LEFT") == 0) {
pelcod_move_left(PTZ_ADDRESS, 0x3f);
} else if(strcmp(cmd, "RIGHT") == 0) {
pelcod_move_right(PTZ_ADDRESS, 0x3f);
}
usleep(CMD_DURATION*1000);
pelcod_move_stop(PTZ_ADDRESS);
stop_event_handler();
return(1);
}
int main()
{
tlog_init(TLOG_MODE_STDERR, TLOG_INFO, NULL);
rcp_connect("10.25.25.220");
start_message_manager();
client_register(RCP_USER_LEVEL_LIVE, "", RCP_REGISTRATION_TYPE_NORMAL, RCP_ENCRYPTION_MODE_MD5);
rcp_coder_list encoders, decoders;
get_coder_list(RCP_CODER_ENCODER, RCP_MEDIA_TYPE_VIDEO, &encoders, 1);
TL_DEBUG("***");
for (int i=0; i<encoders.count; i++)
TL_DEBUG("%x %x %x %x %x", encoders.coder[i].number, encoders.coder[i].caps, encoders.coder[i].current_cap, encoders.coder[i].param_caps, encoders.coder[i].current_param);
TL_DEBUG("***");
get_coder_list(RCP_CODER_DECODER, RCP_MEDIA_TYPE_VIDEO, &decoders, 1);
TL_DEBUG("***");
for (int i=0; i<decoders.count; i++)
TL_DEBUG("%x %x %x %x %x", decoders.coder[i].number, decoders.coder[i].caps, decoders.coder[i].current_cap, decoders.coder[i].param_caps, decoders.coder[i].current_param);
TL_DEBUG("***");
rcp_session session;
memset(&session, 0, sizeof(rcp_session));
unsigned short udp_port = stream_connect_udp(&session);
TL_DEBUG("udp port = %d", udp_port);
rcp_media_descriptor desc = {
RCP_MEP_UDP, 1, 1, 0, udp_port, 0, 1, RCP_VIDEO_CODING_MPEG4, RCP_VIDEO_RESOLUTION_4CIF
};
client_connect(&session, RCP_CONNECTION_METHOD_GET, RCP_MEDIA_TYPE_VIDEO, 0, &desc);
pthread_create(&thread, NULL, keep_alive_thread, &session);
rtp_merge_desc mdesc;
rtp_init(RTP_PAYLOAD_TYPE_H263, 1, &mdesc);
time_t end_time = time(NULL) + 10;
while (time(NULL) < end_time)
{
/*
int num = recvfrom(con.stream_socket, buffer, 1500, 0, (struct sockaddr*)&si_remote, &slen);
rtp_push_frame(buffer, num, &mdesc);
*/
rtp_recv(session.stream_socket, &mdesc);
if (rtp_pop_frame(&mdesc) == 0)
fwrite(mdesc.data, mdesc.frame_lenght, 1, stdout);
}
pthread_cancel(thread);
stop_message_manager();
return 0;
}
int
mb_register(int is_bidi)
{
mb_default_client.id = getpid();
mb_default_client.is_bidi = is_bidi ? 1 : 0;
mb_default_client.source_pages = 0;
return client_register(&mb_default_client);
}
int
mb_register_source(int pages)
{
mb_default_client.id = getpid();
mb_default_client.is_bidi = 1;
mb_default_client.source_pages = pages < 0 ? 0 : pages;
return client_register(&mb_default_client);
}
/*
* This will handle connection for each client
* */
void *connection_handler(void *socket_desc)
{
int sock = *(int*)socket_desc;
int read_size;
char *mess;
message msg;
//Send some messages to the client
mess = "Greetings! I am your connection handler\n";
write(sock , mess , strlen(mess));
mess = "Now type something and i shall repeat what you type \n";
write(sock , mess , strlen(mess));
//Receive a message from client
while( (read_size = recv(sock , &msg , sizeof(msg) , 0)) > 0 )
{
//Send the message back to client
switch(msg.cmd){
case CMD_LOGIN:
login(sock,msg);
bzero(&msg,sizeof(msg));
break;
case CMD_REGISTER:
client_register(sock,msg);
break;
case CMD_SEND_TO:
send_to(msg);
break;
case CMD_LIST_PEOPLE:
who_is_online(sock);
break;
case CMD_EXIT:
client_exit(sock,msg.user_name);
//puts("Client disconnected");
//fflush(stdout);
//free(socket_desc);
break;
}
//write(sock , client_message , strlen(client_message));
}
if(read_size == 0)
{
puts("Client disconnected");
fflush(stdout);
}
else if(read_size == -1)
{
perror("recv failed");
}
//Free the socket pointer
free(socket_desc);
return 0;
}
int main(int argc, char* argv[])
{
if (argc < 2)
{
printf("%s <ip>\n", argv[0]);
return 0;
}
tlog_init(TLOG_MODE_STDERR, TLOG_INFO, NULL);
rcp_connect(argv[1]);
start_message_manager();
client_register(RCP_USER_LEVEL_LIVE, "", RCP_REGISTRATION_TYPE_NORMAL, RCP_ENCRYPTION_MODE_MD5);
int preset_id = get_coder_preset(1);
TL_INFO("preset id = %d", preset_id);
preset_id = get_current_stream_profile(1, 1, &preset_id);
TL_INFO("preset id = %d", preset_id);
preset_set_default(1);
rcp_mpeg4_preset preset;
get_preset(1, &preset, 0);
log_preset(TLOG_INFO, &preset, 0);
strcpy(preset.name, "myConfig");
preset.resolution = PRESET_RESOLUTION_4CIF;
preset.field_mode = PRESET_FIELD_MODE_PROGRESSIVE;
preset.bandwidth = 100000;
preset.bandwidth_soft_limit = 100000;
preset.video_quality = 1;
preset.avc_gop_structure = 0;
preset.averaging_period = 0;
preset.iframe_distance = 31;
preset.avc_pframe_qunatizer_min = 0;
preset.avc_delta_ipquantizer = 5;
set_preset(1, &preset, 0);
get_preset(1, &preset, 0);
log_preset(TLOG_INFO, &preset, 0);
client_unregister();
stop_message_manager();
return 0;
}
void client_find_open_windows(struct WM_t *W)
{
Window *children, root_ret, par_ret;
unsigned int n, i;
XQueryTree(W->XDisplay, W->rootWindow, &root_ret, &par_ret, &children, &n);
registering_existing_windows = 1;
for (i = 0; i < n; i++)
client_register(W, children[i]);
registering_existing_windows = 0;
XFree(children);
}
static int relay_install (relay_server *relay)
{
client_t *client = calloc (1, sizeof (client_t));
connection_init (&client->connection, SOCK_ERROR, NULL);
global_lock();
client_register (client);
global_unlock();
client->shared_data = relay;
client->ops = &relay_init_ops;
client->flags |= CLIENT_ACTIVE;
DEBUG1 ("adding relay client for %s", relay->localmount);
client_add_worker (client);
return 0;
}
int main(void)
{
int i = 0;
tx_control = 0;
link_control = 0;
int a=0;
unsigned char TXT[] = { 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0x01,0x60,0x6E,0x11,0x02,0x0F,
0x08,0x00,0x11,0x22,0x33,0x44,
0x55,0x66,0x77,0x88,0x99,0xAA,
0x55,0x66,0x77,0x88,0x99,0xAA,
0x55,0x66,0x77,0x88,0x99,0xAA,
0x55,0x66,0x77,0x88,0x99,0xAA,
0x55,0x66,0x77,0x88,0x99,0xAA,
0x55,0x66,0x77,0x88,0x99,0xAA,
0x55,0x66,0x77,0x88,0x99,0xAA,
0x00,0x00,0x00,0x20 };
// LCD_Test();
init_lists();
DM9000_init();
//alt_irq_register( JTAG_UART_0_IRQ, NULL, NULL);
//alt_irq_register( UART_0_IRQ, NULL, (void*)uart_interrupt);
// alt_irq_register( TIMER_0_IRQ, NULL, NULL );
// alt_irq_register( TIMER_1_IRQ, NULL, NULL);
// alt_irq_register( BUTTON_PIO_IRQ, NULL, (void*)button_interrupt );
alt_irq_register( DM9000A_IRQ, NULL, (void*)ethernet_interrupts_simple );
// alt_irq_disable_all();
for(i=0; i <2 ; i++)
{
arp_register();
client_register();
}
printf("Client registered\n");
return ethernet_main_loop();
// return 0;
}
int client_main(int argc, char **argv) {
if (argc < 4) {
fprintf(stderr, "Usage: wetalk -c <ip> <uid> <password>\n"
"Or : wetalk -r <ip> <username> <password>\n");
return wetalk_usage("wetalk");
}
int uid = 0;
char *ipaddr = argv[1];
char *password = argv[3];
if (strlen(password) >= PASSWORD_MAX) {
fprintf(stderr, "错误的密码长度\n");
return 1;
}
if (!client_init(argv[1], on_msg_recv)) {
wetalk_error("初始化客户端失败\n");
}
if (!strcmp(argv[0], "-r")) {
uid = client_register(argv[2], password);
if (uid > 0) {
fprintf(stderr, "注册成功，您的 uid 为: %d\n这是以后登陆时必要的信息，请牢记\n回车键以继续", uid);
getchar();
} else {
fprintf(stderr, "注册失败\n");
return 1;
}
} else {
uid = atoi(argv[2]);
if (uid <= 0) {
fprintf(stderr, "错误的uid\n");
return 1;
}
}
if (!client_login(uid, password)) {
wetalk_error("登陆失败\n");
}
client_main_run = true;
int r;
setlocale(LC_ALL, "");
initscr();
getmaxyx(stdscr, window_y, window_x);
char input[BUFFER_SIZE] = {0};
while(client_main_run) {
draw_editarea();
getnstr(input, BUFFER_SIZE - 1);
r = strlen(input);
input[r] = '\0';
if (r > 0) {
client_send(input);
}
}
endwin();
return 0;
}
void server() {
initialize();
int server_sockfd, client_sockfd;
int server_len, client_len;
struct sockaddr_in server_address;
struct sockaddr_in client_address;
int result;
char option[1024];
server_sockfd = socket(AF_INET, SOCK_STREAM, 0);
server_address.sin_family = AF_INET;
server_address.sin_addr.s_addr = htonl(INADDR_ANY);
server_address.sin_port = htons(PORTNO);
server_len = sizeof(server_address);
bind(server_sockfd, (struct sockaddr *) &server_address, server_len);
listen(server_sockfd, 5);
// Creating a queue of connections and initializing readfds to sockfd.
FD_ZERO(&readfds);
FD_SET(server_sockfd, &readfds);
FD_SET(0, &readfds);
while (1) // waiting for client requests
{
int fd;
int nread;
char ch[1024];
testfds = readfds;
result = select(FD_SETSIZE, &testfds, (fd_set *) 0, (fd_set *) 0,
(struct timeval *) 0);
if (result <= 0) {
perror("Error");
exit(1);
}
if (FD_ISSET(0, &testfds)) {
fgets(option, 1024, stdin);
option[strlen(option) - 1] = '\0';
sparse_command(option);
}
else {
for (fd = 0; fd < FD_SETSIZE; fd++) {
if (FD_ISSET(fd, &testfds)) {
if (fd == server_sockfd)
{
client_sockfd = accept(server_sockfd,
(struct sockaddr *) &client_address,
&client_len);
FD_SET(client_sockfd, &readfds);
}
else {
memset(ch, 0, 1024);
ioctl(fd, FIONREAD, &nread);
if (nread == 0)
{
remove_client(fd);
close(fd);
FD_CLR(fd, &readfds);
send_table();
} else {
read(fd, &ch, sizeof(ch));
char temp[1024];
bzero(temp, 1024);
strcpy(temp, ch);
char* reader2;
reader2 = strtok(temp, ":");
/**registering the client***/
if (strstr(ch, "Register") != NULL) {
client_register(ch, fd);
memset(ch, 0, 1024);
}
else {
bzero(ch, 1024);
bzero(temp, 1024);
}
}
}
}
}
}
}
}
int main(int argc, char* argv[])
{
tlog_init(TLOG_MODE_STDERR, TLOG_INFO, NULL);
if (argc < 3)
{
TL_INFO("%s <ip> <output>", argv[0]);
return 0;
}
rcp_connect(argv[1]);
start_message_manager();
client_register(RCP_USER_LEVEL_LIVE, "", RCP_REGISTRATION_TYPE_NORMAL, RCP_ENCRYPTION_MODE_MD5);
rcp_coder_list encoders, decoders;
get_coder_list(RCP_CODER_ENCODER, RCP_MEDIA_TYPE_VIDEO, &encoders, 1);
TL_DEBUG("***");
for (int i=0; i<encoders.count; i++)
TL_DEBUG("%x %x %x %x %x", encoders.coder[i].number, encoders.coder[i].caps, encoders.coder[i].current_cap, encoders.coder[i].param_caps, encoders.coder[i].current_param);
TL_DEBUG("***");
get_coder_list(RCP_CODER_DECODER, RCP_MEDIA_TYPE_VIDEO, &decoders, 1);
TL_DEBUG("***");
for (int i=0; i<decoders.count; i++)
TL_DEBUG("%x %x %x %x %x", decoders.coder[i].number, decoders.coder[i].caps, decoders.coder[i].current_cap, decoders.coder[i].param_caps, decoders.coder[i].current_param);
TL_DEBUG("***");
rcp_session session;
memset(&session, 0, sizeof(rcp_session));
unsigned short udp_port = stream_connect_udp(&session);
TL_DEBUG("udp port = %d", udp_port);
rcp_media_descriptor desc = {
RCP_MEP_UDP, 1, 1, 0, udp_port, 1, 1, RCP_VIDEO_CODING_H264, RCP_VIDEO_RESOLUTION_4CIF
};
client_connect(&session, RCP_CONNECTION_METHOD_GET, RCP_MEDIA_TYPE_VIDEO, 0, &desc);
pthread_create(&thread, NULL, keep_alive_thread, &session);
rtp_merge_desc mdesc;
rtp_init(RTP_PAYLOAD_TYPE_H264, 1, &mdesc);
signal(SIGTERM, term_handler);
FILE * out = fopen(argv[2], "wb");
while (!end)
{
/*
int num = recvfrom(con.stream_socket, buffer, 1500, 0, (struct sockaddr*)&si_remote, &slen);
rtp_push_frame(buffer, num, &mdesc);
*/
if (rtp_recv(session.stream_socket, &mdesc) == 0)
{
if (rtp_pop_frame(&mdesc) == 0)
{
fwrite(mdesc.data, mdesc.frame_lenght, 1, out);
}
}
//char cmd[100];
//sprintf(cmd, "kill %d", res);
//system(cmd);
//return 0;
}
fclose(out);
pthread_cancel(thread);
client_disconnect(&session);
client_unregister();
stop_message_manager();
return 0;
}
int main()
{
tlog_init(TLOG_MODE_STDERR, TLOG_INFO, NULL);
rcp_connect("10.25.25.223");
start_event_handler();
client_register(RCP_USER_LEVEL_LIVE, "", RCP_REGISTRATION_TYPE_NORMAL, RCP_ENCRYPTION_MODE_MD5);
rcp_coder_list encoders, decoders;
get_coder_list(RCP_CODER_ENCODER, RCP_MEDIA_TYPE_VIDEO, &encoders, 1);
TL_DEBUG("***");
for (int i=0; i<encoders.count; i++)
TL_DEBUG("%x %x %x %x %x", encoders.coder[i].number, encoders.coder[i].caps, encoders.coder[i].current_cap, encoders.coder[i].param_caps, encoders.coder[i].current_param);
TL_DEBUG("***");
get_coder_list(RCP_CODER_DECODER, RCP_MEDIA_TYPE_VIDEO, &decoders, 1);
TL_DEBUG("***");
for (int i=0; i<decoders.count; i++)
TL_DEBUG("%x %x %x %x %x", decoders.coder[i].number, decoders.coder[i].caps, decoders.coder[i].current_cap, decoders.coder[i].param_caps, decoders.coder[i].current_param);
TL_DEBUG("***");
rcp_session session;
memset(&session, 0, sizeof(rcp_session));
unsigned short tcp_port = stream_connect_tcp(&session);
rcp_media_descriptor desc = {
RCP_MEP_TCP, 1, 1, 0, tcp_port, 0, 1, RCP_VIDEO_CODING_H263P, RCP_VIDEO_RESOLUTION_4CIF
};
client_connect(&session, RCP_CONNECTION_METHOD_GET, RCP_MEDIA_TYPE_VIDEO, 0, &desc);
initiate_tcp_stream(&session, &decoders.coder[0]);
int res = fork();
if (res == 0)
{
while (1)
{
sleep(2);
int n = keep_alive(&session);
//TL_DEBUG("active connections = %d", n);
if (n < 0)
break;
}
}
rtp_merge_desc mdesc;
rtp_init(RTP_PAYLOAD_TYPE_H263, 1, &mdesc);
time_t end_time = time(NULL) + 10;
while (time(NULL) < end_time)
{
/*
int num = recv(con.stream_socket, buffer, 1500, 0);
rtp_push_frame(buffer, num, &mdesc);
*/
char buff[2000];
int size = recv(session.stream_socket, buff, 1000, 0);
fwrite(buff, size, 1, stdout);
/*
rtp_recv(session.stream_socket, &mdesc);
if (rtp_pop_frame(&mdesc) == 0)
fwrite(mdesc.data, mdesc.frame_lenght, 1, stdout);
*/
}
stop_event_handler();
return 0;
}
static client_t *accept_client (void)
{
client_t *client = NULL;
sock_t sock, serversock = wait_for_serversock ();
char addr [200];
if (serversock == SOCK_ERROR)
return NULL;
sock = sock_accept (serversock, addr, 200);
if (sock == SOCK_ERROR)
{
if (sock_recoverable (sock_error()))
return NULL;
WARN2 ("accept() failed with error %d: %s", sock_error(), strerror(sock_error()));
thread_sleep (500000);
return NULL;
}
do
{
int i, num;
refbuf_t *r;
if (sock_set_blocking (sock, 0) || sock_set_nodelay (sock))
{
WARN0 ("failed to set tcp options on client connection, dropping");
break;
}
client = calloc (1, sizeof (client_t));
if (client == NULL || connection_init (&client->connection, sock, addr) < 0)
break;
client->shared_data = r = refbuf_new (PER_CLIENT_REFBUF_SIZE);
r->len = 0; // for building up the request coming in
global_lock ();
client_register (client);
for (i=0; i < global.server_sockets; i++)
{
if (global.serversock[i] == serversock)
{
client->server_conn = global.server_conn[i];
client->server_conn->refcount++;
if (client->server_conn->ssl && ssl_ok)
connection_uses_ssl (&client->connection);
if (client->server_conn->shoutcast_compat)
client->ops = &shoutcast_source_ops;
else
client->ops = &http_request_ops;
break;
}
}
num = global.clients;
global_unlock ();
stats_event_args (NULL, "clients", "%d", num);
client->flags |= CLIENT_ACTIVE;
return client;
} while (0);
free (client);
sock_close (sock);
return NULL;
}
int main(int argc, char* argv[])
{
tlog_init(TLOG_MODE_STDERR, TLOG_INFO, NULL);
if (argc < 2)
{
TL_INFO("%s ip\n", argv[0]);
return 0;
}
rcp_connect(argv[1]);
start_event_handler();
client_register(RCP_USER_LEVEL_LIVE, "", RCP_REGISTRATION_TYPE_NORMAL, RCP_ENCRYPTION_MODE_MD5);
rcp_coder_list encoders;
get_coder_list(RCP_CODER_DECODER, RCP_MEDIA_TYPE_VIDEO, &encoders, 2);
int preset_id = get_coder_preset(8);
rcp_mpeg4_preset preset;
get_preset(preset_id, &preset, 1);
log_preset(TLOG_INFO, &preset, 1);
preset.resolution = RCP_VIDEO_RESOLUTION_4CIF;
set_preset(preset_id, &preset, 1);
log_preset(TLOG_INFO, &preset, 1);
/*
for (int i=0; i<encoders.count; i++)
{
int mode;
get_coder_video_operation_mode(encoders.coder[i].number, &mode);
TL_INFO("video mode is %d", mode);
TL_INFO("%x %x %x %x %x", encoders.coder[i].number, encoders.coder[i].caps, encoders.coder[i].current_cap, encoders.coder[i].param_caps, encoders.coder[i].current_param);
log_coder(TLOG_INFO, &encoders.coder[i]);
mode = (mode==1)?2:1;
mode = set_coder_video_operation_mode(encoders.coder[i].number, mode);
TL_INFO("video mode is %d", mode);
TL_INFO("-----------------------");
}
get_coder_list(RCP_CODER_ENCODER, RCP_MEDIA_TYPE_VIDEO, &encoders, 1);
for (int i=0; i<encoders.count; i++)
{
int mode;
get_coder_video_operation_mode(encoders.coder[i].number, &mode);
TL_INFO("video mode is %d", mode);
TL_INFO("%x %x %x %x %x", encoders.coder[i].number, encoders.coder[i].caps, encoders.coder[i].current_cap, encoders.coder[i].param_caps, encoders.coder[i].current_param);
log_coder(TLOG_INFO, &encoders.coder[i]);
mode = (mode==1)?2:1;
mode = set_coder_video_operation_mode(encoders.coder[i].number, mode);
TL_INFO("video mode is %d", mode);
TL_INFO("-----------------------");
}
get_coder_list(RCP_CODER_DECODER, RCP_MEDIA_TYPE_AUDIO, &encoders, 1);
for (int i=0; i<encoders.count; i++)
{
TL_INFO("%x %x %x %x %x", encoders.coder[i].number, encoders.coder[i].caps, encoders.coder[i].current_cap, encoders.coder[i].param_caps, encoders.coder[i].current_param);
log_coder(TLOG_INFO, &encoders.coder[i]);
TL_INFO("-----------------------");
}
*/
stop_event_handler();
return 0;
}
