u8 set_802_11_authentication_mode(_adapter *padapter, NDIS_802_11_AUTHENTICATION_MODE authmode) { struct security_priv *psecuritypriv = &padapter->securitypriv; u8 ret; _func_enter_; RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_notice_,("+set_802_11_auth_mode: mode=%d\n", authmode)); psecuritypriv->ndisauthtype = authmode; if (psecuritypriv->ndisauthtype > 3) psecuritypriv->dot11AuthAlgrthm = 2; // 802.1x if (set_auth(padapter, psecuritypriv) == _SUCCESS) ret = _TRUE; else { ret = _FALSE; RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,("!set_802_11_auth_mode: fail!!\n")); } _func_exit_; return ret; }
int main(int argc, char *argv[]) { /* read command line arguments */ int c; char *err = NULL; char *p, *q; int auth_mode = AUTH_OFF; char *auth_username = NULL; char *auth_password = NULL; char *auth_realm = NULL; opterr = 0; while ((c = getopt(argc, argv, "a:c:dhlm:p:qs:t:")) != -1) { switch (c) { case 'a': /* authentication */ if (!strcmp(optarg, "basic")) { auth_mode = AUTH_BASIC; } break; case 'c': /* credentials */ p = q = optarg; while (*q && *q != ':') { q++; } auth_username = strndup(p, q - p); if (!*q) { ERROR("invalid credentials"); return -1; } p = q = q + 1; while (*q && *q != ':') { q++; } auth_password = strndup(p, q - p); if (!*q) { ERROR("invalid credentials"); return -1; } p = q = q + 1; while (*q && *q != ':') { q++; } auth_realm = strndup(p, q - p); break; case 'd': /* debug */ log_level = 2; break; case 'h': /* help */ print_help(); return 0; case 'l': /* listen on localhost */ listen_localhost = 1; break; case 'm': /* max clients */ max_clients = strtol(optarg, &err, 10); if (*err != 0) { ERROR("invalid clients number \"%s\"", optarg); return -1; } break; case 'p': /* tcp port */ tcp_port = strtol(optarg, &err, 10); if (*err != 0) { ERROR("invalid port \"%s\"", optarg); return -1; } break; case 'q': /* quiet */ log_level = 0; break; case 's': /* input separator */ input_separator = strdup(optarg); break; case 't': /* client timeout */ client_timeout = strtol(optarg, &err, 10); if (*err != 0) { ERROR("invalid client timeout \"%s\"", optarg); return -1; } break; case '?': ERROR("unknown or incomplete option \"-%c\"", optopt); return -1; default: print_help(); return -1; } } if (auth_mode) { if (!auth_username || !auth_password || !auth_realm) { ERROR("credentials are required when using authentication"); return -1; } set_auth(auth_mode, auth_username, auth_password, auth_realm); } if (!tcp_port) { tcp_port = DEF_TCP_PORT; } INFO("streamEye %s", STREAM_EYE_VERSION); INFO("hello!"); if (input_separator && strlen(input_separator) < 4) { INFO("the input separator supplied is very likely to appear in the actual frame data (consider a longer one)"); } /* signals */ DEBUG("installing signal handlers"); struct sigaction act; act.sa_handler = bye_handler; act.sa_flags = 0; sigemptyset(&act.sa_mask); if (sigaction(SIGINT, &act, NULL) < 0) { ERRNO("sigaction() failed"); return -1; } if (sigaction(SIGTERM, &act, NULL) < 0) { ERRNO("sigaction() failed"); return -1; } if (signal(SIGPIPE, SIG_IGN) == SIG_ERR) { ERRNO("signal() failed"); return -1; } /* threading */ DEBUG("initializing thread synchronization"); if (pthread_cond_init(&jpeg_cond, NULL)) { ERROR("pthread_cond_init() failed"); return -1; } if (pthread_mutex_init(&jpeg_mutex, NULL)) { ERROR("pthread_mutex_init() failed"); return -1; } if (pthread_mutex_init(&clients_mutex, NULL)) { ERROR("pthread_mutex_init() failed"); return -1; } /* tcp server */ DEBUG("starting server"); int socket_fd = init_server(); if (socket_fd < 0) { ERROR("failed to start server"); return -1; } INFO("listening on %s:%d", listen_localhost ? "127.0.0.1" : "0.0.0.0", tcp_port); /* main loop */ char input_buf[INPUT_BUF_LEN]; char *sep = NULL; int size, rem_len = 0, i; double now, min_client_frame_int; double frame_int_adj; double frame_int = 0; double last_frame_time = get_now(); int auto_separator = 0; int input_separator_len; if (!input_separator) { auto_separator = 1; input_separator_len = 4; /* strlen(JPEG_START) + strlen(JPEG_END) */; input_separator = malloc(input_separator_len + 1); snprintf(input_separator, input_separator_len + 1, "%s%s", JPEG_END, JPEG_START); } else { input_separator_len = strlen(input_separator); } while (running) { size = read(STDIN_FILENO, input_buf, INPUT_BUF_LEN); if (size < 0) { if (errno == EINTR) { break; } ERRNO("input: read() failed"); return -1; } else if (size == 0) { DEBUG("input: end of stream"); running = 0; break; } if (size > JPEG_BUF_LEN - 1 - jpeg_size) { ERROR("input: jpeg size too large, discarding buffer"); jpeg_size = 0; continue; } if (pthread_mutex_lock(&jpeg_mutex)) { ERROR("pthread_mutex_lock() failed"); return -1; } /* clear the ready flag for all clients, * as we start building the next frame */ for (i = 0; i < num_clients; i++) { clients[i]->jpeg_ready = 0; } if (rem_len) { /* copy the remainder of data from the previous iteration back to the jpeg buffer */ memmove(jpeg_buf, sep + (auto_separator ? 2 /* strlen(JPEG_END) */ : input_separator_len), rem_len); jpeg_size = rem_len; } memcpy(jpeg_buf + jpeg_size, input_buf, size); jpeg_size += size; /* look behind at most 2 * INPUT_BUF_LEN for a separator */ sep = (char *) memmem(jpeg_buf + jpeg_size - MIN(2 * INPUT_BUF_LEN, jpeg_size), MIN(2 * INPUT_BUF_LEN, jpeg_size), input_separator, input_separator_len); if (sep) { /* found a separator, jpeg frame is ready */ if (auto_separator) { rem_len = jpeg_size - (sep - jpeg_buf) - 2 /* strlen(JPEG_START) */; jpeg_size = sep - jpeg_buf + 2 /* strlen(JPEG_END) */; } else { rem_len = jpeg_size - (sep - jpeg_buf) - input_separator_len; jpeg_size = sep - jpeg_buf; } DEBUG("input: jpeg buffer ready with %d bytes", jpeg_size); /* set the ready flag and notify all client threads about it */ for (i = 0; i < num_clients; i++) { clients[i]->jpeg_ready = 1; } if (pthread_cond_broadcast(&jpeg_cond)) { ERROR("pthread_cond_broadcast() failed"); return -1; } now = get_now(); frame_int = frame_int * 0.7 + (now - last_frame_time) * 0.3; last_frame_time = now; } else { rem_len = 0; } if (pthread_mutex_unlock(&jpeg_mutex)) { ERROR("pthread_mutex_unlock() failed"); return -1; } if (sep) { DEBUG("current fps: %.01lf", 1 / frame_int); if (num_clients) { min_client_frame_int = clients[0]->frame_int; for (i = 0; i < num_clients; i++) { if (clients[i]->frame_int < min_client_frame_int) { min_client_frame_int = clients[i]->frame_int; } } frame_int_adj = (min_client_frame_int - frame_int) * 1000000; if (frame_int_adj > 0) { DEBUG("input frame int.: %.0lf us, client frame int.: %.0lf us, frame int. adjustment: %.0lf us", frame_int * 1000000, min_client_frame_int * 1000000, frame_int_adj); /* sleep between 1000 and 50000 us, depending on the frame interval adjustment */ usleep(MAX(1000, MIN(4 * frame_int_adj, 50000))); } } /* check for incoming clients; * placing this code inside the if (sep) will simply * reduce the number of times we check for incoming clients, * with no particular relation to the frame separator we've just found */ client_t *client = NULL; if (!max_clients || num_clients < max_clients) { client = wait_for_client(socket_fd); } if (client) { if (pthread_create(&client->thread, NULL, (void *(*) (void *)) handle_client, client)) { ERROR("pthread_create() failed"); return -1; } if (pthread_mutex_lock(&clients_mutex)) { ERROR("pthread_mutex_lock() failed"); return -1; } clients = realloc(clients, sizeof(client_t *) * (num_clients + 1)); clients[num_clients++] = client; DEBUG("current clients: %d", num_clients); if (pthread_mutex_unlock(&clients_mutex)) { ERROR("pthread_mutex_unlock() failed"); return -1; } } } } running = 0; DEBUG("closing server"); close(socket_fd); DEBUG("waiting for clients to finish"); for (i = 0; i < num_clients; i++) { clients[i]->jpeg_ready = 1; } if (pthread_cond_broadcast(&jpeg_cond)) { ERROR("pthread_cond_broadcast() failed"); return -1; } for (i = 0; i < num_clients; i++) { pthread_join(clients[i]->thread, NULL); } if (pthread_mutex_destroy(&clients_mutex)) { ERROR("pthread_mutex_destroy() failed"); return -1; } if (pthread_mutex_destroy(&jpeg_mutex)) { ERROR("pthread_mutex_destroy() failed"); return -1; } if (pthread_cond_destroy(&jpeg_cond)) { ERROR("pthread_cond_destroy() failed"); return -1; } INFO("bye!"); return 0; }