th_pkt_t *
avc_convert_pkt(th_pkt_t *src)
{
th_pkt_t *pkt = malloc(sizeof(th_pkt_t));
*pkt = *src;
pkt->pkt_refcount = 1;
pkt->pkt_header = NULL;
pkt->pkt_payload = NULL;
if (src->pkt_header) {
sbuf_t headers;
sbuf_init(&headers);
isom_write_avcc(&headers, pktbuf_ptr(src->pkt_header),
pktbuf_len(src->pkt_header));
pkt->pkt_header = pktbuf_make(headers.sb_data, headers.sb_ptr);
}
sbuf_t payload;
sbuf_init(&payload);
if(src->pkt_header)
avc_parse_nal_units(&payload, pktbuf_ptr(src->pkt_header),
pktbuf_len(src->pkt_header));
avc_parse_nal_units(&payload, pktbuf_ptr(src->pkt_payload),
pktbuf_len(src->pkt_payload));
pkt->pkt_payload = pktbuf_make(payload.sb_data, payload.sb_ptr);
pkt_ref_dec(src);
return pkt;
}
void testStaticBuffer(
Test * pTest)
{
STATIC_BUFFER sbuffer;
char *data1 = "Joshua";
char *data2 = "Anna";
char *data3 = "Christopher";
char *data4 = "Mary";
char data_buffer[480] = "";
char test_data_buffer[480] = "";
char *data;
unsigned count;
sbuf_init(&sbuffer, NULL, 0);
ct_test(pTest, sbuf_empty(&sbuffer) == true);
ct_test(pTest, sbuf_data(&sbuffer) == NULL);
ct_test(pTest, sbuf_size(&sbuffer) == 0);
ct_test(pTest, sbuf_count(&sbuffer) == 0);
ct_test(pTest, sbuf_append(&sbuffer, data1, strlen(data1)) == false);
sbuf_init(&sbuffer, data_buffer, sizeof(data_buffer));
ct_test(pTest, sbuf_empty(&sbuffer) == true);
ct_test(pTest, sbuf_data(&sbuffer) == data_buffer);
ct_test(pTest, sbuf_size(&sbuffer) == sizeof(data_buffer));
ct_test(pTest, sbuf_count(&sbuffer) == 0);
ct_test(pTest, sbuf_append(&sbuffer, data1, strlen(data1)) == true);
ct_test(pTest, sbuf_append(&sbuffer, data2, strlen(data2)) == true);
ct_test(pTest, sbuf_append(&sbuffer, data3, strlen(data3)) == true);
ct_test(pTest, sbuf_append(&sbuffer, data4, strlen(data4)) == true);
strcat(test_data_buffer, data1);
strcat(test_data_buffer, data2);
strcat(test_data_buffer, data3);
strcat(test_data_buffer, data4);
ct_test(pTest, sbuf_count(&sbuffer) == strlen(test_data_buffer));
data = sbuf_data(&sbuffer);
count = sbuf_count(&sbuffer);
ct_test(pTest, memcmp(data, test_data_buffer, count) == 0);
ct_test(pTest, count == strlen(test_data_buffer));
ct_test(pTest, sbuf_truncate(&sbuffer, 0) == true);
ct_test(pTest, sbuf_count(&sbuffer) == 0);
ct_test(pTest, sbuf_size(&sbuffer) == sizeof(data_buffer));
ct_test(pTest, sbuf_append(&sbuffer, data4, strlen(data4)) == true);
data = sbuf_data(&sbuffer);
count = sbuf_count(&sbuffer);
ct_test(pTest, memcmp(data, data4, count) == 0);
ct_test(pTest, count == strlen(data4));
return;
}
/* evaluate .if strcmp (i.e. 'str'str') */
static int if_strcmp(int (*next)(void), void (*back)(int))
{
char delim[GNLEN];
struct sbuf s1, s2;
int ret;
charnext(delim, next, back);
sbuf_init(&s1);
sbuf_init(&s2);
read_until(&s1, delim, next, back);
read_until(&s2, delim, next, back);
cp_reqbeg();
ret = !strcmp(sbuf_buf(&s1), sbuf_buf(&s2));
sbuf_done(&s1);
sbuf_done(&s2);
return ret;
}
/* expand a macro; return zero on success */
static int tok_expand(void)
{
char *args[10] = {NULL};
struct sbuf sbufs[10];
int i, n = 0;
tok_preview(tok);
if (src_macro(tok)) {
int c = src_next();
src_back(c);
if (c == '(') { /* macro arguments follow */
src_next();
while (n <= 9) {
sbuf_init(&sbufs[n]);
if (tok_readarg(&sbufs[n++]))
break;
}
}
for (i = 0; i < n; i++)
args[i] = sbuf_buf(&sbufs[i]);
src_expand(tok, args);
for (i = 0; i < n; i++)
sbuf_done(&sbufs[i]);
return 0;
}
tok_unpreview(tok);
return 1;
}
int main(int argc, char *argv[]){
pthread_t tidProducer, tidConsumer;
int i;
int err;
sbuf_init(NUMS);
err = pthread_create(&tidProducer, NULL, producer, (void*)(&sb));
if (err != 0){
fprintf(stderr, "pthread_create error\n");
exit(EXIT_FAILURE);
}
err = pthread_create(&tidConsumer, NULL, consumer, (void*)(&sb));
if(err != 0){
fprintf(stderr, "pthread_create error\n");
exit(EXIT_FAILURE);
}
sleep(10);
pthread_kill(tidProducer, 0);
pthread_kill(tidConsumer, 0);
sbuf_deinit(sp);
return 0;
}
void mkdir_p(const char *path)
{
struct sbuf s;
char *p;
sbuf_init(&s);
if (strlen(path) > PATH_MAX) {
warn("mkdir_p: path too long");
return;
}
sbuf_cpy(&s, path);
if (!s.len)
return;
sbuf_expand_tilde(&s);
if (s.buf[s.len - 1] != '/')
sbuf_addch(&s, '/');
for (p = s.buf + 1; *p; p++) {
if (*p != '/')
continue;
*p = '\0';
if (mkdir(s.buf, S_IRWXU) != 0 && errno != EEXIST)
warn("mkdir_p: could not create '%s'", s.buf);
*p = '/';
}
}
int main(int argc, char **argv)
{
int listenfd, connfd;
char hostname[MAXLINE], port[MAXLINE];
socklen_t clientlen;
struct sockaddr_storage clientaddr;
pthread_t tid;
if (argc != 2) {
fprintf(stderr, "usage: %s <port>\n", argv[0]);
exit(1);
}
listenfd = Open_listenfd(argv[1]);
sbuf_init(&sbuf, bufferSize); //初始化结构
int i;
for(i = 0; i < MAXThreads; ++i) Pthread_create(&tid,NULL,thread,NULL);
while (1) {
clientlen = sizeof(clientaddr);
connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen);
Getnameinfo((SA *) &clientaddr, clientlen, hostname, MAXLINE,
port, MAXLINE, 0);
printf("Accepted connection from (%s, %s)\n", hostname, port);
sbuf_insert(&sbuf, connfd); //生产者加入描述符
}
sbuf_deinit(&sbuf); //释放buffer
return 0;
}
/* After intiall error checks, bind and listen to the provided port
* start some helper threads, then accept connections and place them in
* the shared buffer for a helper thread to process.
*/
int main(int argc, char** argv)
{
int i, listenport, listenfd, connfd;
unsigned clientlen;
sockaddr_in clientaddr;
pthread_t tid;
if(argc < 2){
printf("usage: %s <port number to bind and listen>\n", argv[0]);
exit(1);
}
Sem_init(&w, 0, 1);
num_entries = 0;
cache = NULL;
listenport = atoi(argv[1]);
sbuf_init(&sbuf, SBUFSIZE);
listenfd = Open_listenfd(listenport);
clientlen = sizeof(clientaddr);
for(i = 0; i < NTHREADS; i++) /* prethreading, creating worker threads */
Pthread_create(&tid, NULL, thread, &clientaddr);
while(1){
connfd = Accept(listenfd, (SA *) &clientaddr, &clientlen);
sbuf_insert(&sbuf, connfd); // put in buffer
}
return 0;
}
int main(int argc, char *argv[])
{
int i, listenfd, connfd, port;
struct sockaddr_in clientaddr;
int clientlen = sizeof(clientaddr);
pthread_t tid;
if(argc != 2)
{
printf("usgage: %s <port>", argv[0]);
exit(0);
}
sbuf_init(&sbuf, SBUFSIZE);
port = atoi(argv[1]);
listenfd = Open_listenfd(port);
for (i =0 ; i< NTHREADS ; i++)
Pthread_create(&tid, NULL, thread, NULL);
while (1)
{
connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen);
sbuf_insert(&sbuf, connfd);
}
}
int main (int argc, char *argv[])
{
int i, listenfd, connfd, port;
socklen_t clientlen = sizeof (struct sockaddr_in);
struct sockaddr_in clientaddr;
pthread_t tid;
if (argc != 2)
{
wp_critical ("usage: %s <port>\n", argv[0]);
}
port = atoi (argv[1]);
sbuf_init (&sbuf, SBUFSIZE);
listenfd = wp_open_listenfd (port);
if (listenfd < 0)
{
wp_critical ("error");
}
for (i = 0; i < NTHREADS; i++)
{
wp_pthread_create (&tid, NULL, thread, NULL);
}
while (1)
{
connfd = wp_accept (listenfd, (struct sockaddr *)&clientaddr, &clientlen);
sbuf_insert (&sbuf, connfd);
}
}
char *i18n_set_translation_file(const char *filename)
{
struct stat st;
struct sbuf s;
sbuf_init(&s);
sbuf_cpy(&s, filename);
sbuf_expand_tilde(&s);
if (stat(s.buf, &st) < 0) {
warn("i18n: file '%s' does not exist", s.buf);
translation_file = NULL;
xfree(s.buf);
return NULL;
}
if (S_ISDIR(st.st_mode)) {
find_translation_file_within_dir(&s);
if (!s.len) {
warn("i18n: could not find translation file in dir '%s'",
filename);
translation_file = NULL;
xfree(s.buf);
return NULL;
}
}
translation_file = s.buf;
info("i18n: translation file '%s' loaded", translation_file);
i18n_open();
return translation_file;
}
/* read a string argument of a macro */
static char *read_string(void)
{
struct sbuf sbuf;
int c;
int empty;
sbuf_init(&sbuf);
cp_copymode(1);
while ((c = cp_next()) == ' ')
;
empty = c <= 0 || c == '\n';
if (c == '"')
c = cp_next();
while (c > 0 && c != '\n') {
if (c != c_ni)
sbuf_add(&sbuf, c);
c = cp_next();
}
if (c >= 0)
cp_back(c);
cp_copymode(0);
if (empty) {
sbuf_done(&sbuf);
return NULL;
}
return sbuf_out(&sbuf);
}
/** @brief Main method of server.
* Opens listening ports and initiates synchronized buffer.
* Creates a pool of worker threads that will act on descriptors
* in the buffer.
* Loops and adds new connection descriptors to buffer.
* @param argc Number of command line arguments.
* @param argv Command line arguments, contains port number.
* @return EXIT CODE
*/
int main(int argc, char **argv)
{
int listen_fd, conn_fd, port, i;
struct sockaddr_in client_addr;
socklen_t client_len = sizeof(client_addr);
pthread_t tid;
if (argc != 2) {
printf("Usage: %s <port>\n", argv[0]);
return -1;
}
/* bind listen_fd to port */
port = atoi(argv[1]);
listen_fd = Open_listenfd(port);
/* Initialize shared buffer */
sbuf_init(&sbuf, SBUFSIZE);
/* Pre-spawn all worker threads */
for (i = 0; i < NTHREADS; i++) {
Pthread_create(&tid, NULL, conn_handler, NULL);
}
/* Accept new connections and add to shared buffer */
while (1) {
conn_fd = accept(listen_fd, (SA *) &client_addr, &client_len);
if (conn_fd < 0) continue;
sbuf_insert(&sbuf, conn_fd);
}
return 0;
}
int main(int argc, char **argv)
{
int i, listenfd, connfd, port;
struct sockaddr_in clientaddr;
socklen_t clientlen = sizeof(clientaddr);
pthread_t tid;
/* Check command line args */
if (argc != 2) {
fprintf(stderr, "usage: %s <port>\n", argv[0]);
exit(1);
}
port = atoi(argv[1]);
sbuf_init(&sbuf, SBUF_SIZE);
listenfd = Open_listenfd(port);
for (int i = 0; i < THREAD_NUM; i++)
{
Pthread_create(&tid, NULL, thread_func, NULL);
}
while (1) {
connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen);
sbuf_insert(&sbuf, connfd);
}
}
void
download_init( download_t *dn, const char *log )
{
memset(dn, 0, sizeof(*dn));
dn->log = strdup(log);
dn->pipe_fd = -1;
sbuf_init(&dn->pipe_sbuf);
}
/* read macro arguments; free the returned pointer when done */
char *tr_args(char **args, int brk, int (*next)(void), void (*back)(int))
{
struct sbuf sbuf;
sbuf_init(&sbuf);
while (!macroarg(&sbuf, brk, next, back))
;
chopargs(&sbuf, args);
return sbuf_out(&sbuf);
}
/* read the next troff request; return zero if a request was executed. */
int tr_nextreq(void)
{
char *mac;
char *arg0 = NULL;
int c;
if (!tr_nl)
return 1;
c = cp_next();
/* transparent line indicator */
if (c == c_ec) {
int c2 = cp_next();
if (c2 == '!') {
char *args[NARGS + 3] = {"\\!"};
struct sbuf sbuf;
sbuf_init(&sbuf);
cp_copymode(1);
mkargs_eol(&sbuf);
cp_copymode(0);
chopargs(&sbuf, args + 1);
tr_transparent(args);
sbuf_done(&sbuf);
return 0;
}
cp_back(c2);
}
/* not a request, a blank line, or a line with leading spaces */
if (c < 0 || (c != c_cc && c != c_c2 &&
(c != '\n' || tr_bm < 0) &&
(c != ' ' || tr_sm < 0))) {
cp_back(c);
return 1;
}
cp_reqbeg();
if (c == '\n') { /* blank line macro */
mac = malloc(strlen(map_name(tr_bm)) + 1);
strcpy(mac, map_name(tr_bm));
arg0 = dotted(mac, '.');
tr_nextreq_exec(mac, arg0, 0);
} else if (c == ' ') { /* leading space macro */
int i;
mac = malloc(strlen(map_name(tr_sm)) + 1);
strcpy(mac, map_name(tr_sm));
for (i = 0; c == ' '; i++)
c = cp_next();
cp_back(c);
n_lsn = i;
arg0 = dotted(mac, '.');
tr_nextreq_exec(mac, arg0, 0);
} else {
mac = read_name(n_cp);
arg0 = dotted(mac, c);
tr_nextreq_exec(mac, arg0, 1);
}
free(arg0);
free(mac);
return 0;
}
static void construct_server(void *obj)
{
PgSocket *server = obj;
memset(server, 0, sizeof(PgSocket));
list_init(&server->head);
sbuf_init(&server->sbuf, server_proto);
server->state = SV_FREE;
}
static void construct_client(void *obj)
{
PgSocket *client = obj;
memset(client, 0, sizeof(PgSocket));
list_init(&client->head);
sbuf_init(&client->sbuf, client_proto);
client->state = CL_FREE;
}
void* sbuf_alloc()
{
if (is_inited == RT_FALSE)
{
sbuf_init();
is_inited = RT_TRUE;
}
return (rt_uint16_t*)rt_mp_alloc(&_mp, RT_WAITING_FOREVER);
}
/* evaluate .if condition */
static int if_eval(int (*next)(void), void (*back)(int))
{
struct sbuf sbuf;
int ret;
sbuf_init(&sbuf);
read_until(&sbuf, NULL, next, back);
ret = eval(sbuf_buf(&sbuf), '\0') > 0;
sbuf_done(&sbuf);
return ret;
}
/* read the next macro command */
void tok_macro(void)
{
char name[NMLEN];
struct sbuf def;
tok_preview(name);
sbuf_init(&def);
tok_macrodef(&def);
src_define(name, sbuf_buf(&def));
sbuf_done(&def);
}
static int
avc_parse_nal_units_buf(const uint8_t *buf_in, uint8_t **buf, int *size)
{
sbuf_t sb;
sbuf_init(&sb);
avc_parse_nal_units(&sb, buf_in, *size);
free(*buf);
*buf = sb.sb_data;
*size = sb.sb_ptr;
return 0;
}
static void construct_client(void *obj)
{
PgSocket *client = obj;
memset(client, 0, sizeof(PgSocket));
list_init(&client->head);
sbuf_init(&client->sbuf, client_proto);
client->state = CL_FREE;
client->tx_state = TX_NONE;
client->sharding_initialized = false;
client->sharding_key = NULL;
client->cluster = NULL;
}
static void tr_coa(char **args)
{
char *src = args[1];
char *dst = args[2];
if (src && dst && str_get(map(src))) {
struct sbuf sb;
sbuf_init(&sb);
if (str_get(map(dst)))
sbuf_append(&sb, str_get(map(dst)));
sbuf_append(&sb, str_get(map(src)));
str_set(map(dst), sbuf_buf(&sb));
sbuf_done(&sb);
}
}
static void tr_chop(char **args)
{
struct sbuf sbuf;
int id;
id = map(args[1]);
if (str_get(id)) {
sbuf_init(&sbuf);
sbuf_append(&sbuf, str_get(id));
if (!sbuf_empty(&sbuf)) {
sbuf_cut(&sbuf, sbuf_len(&sbuf) - 1);
str_set(id, sbuf_buf(&sbuf));
}
sbuf_done(&sbuf);
}
}
/*
Send a complete receiver report (RR).
It uses the actual informations stored in rtcp_info.
*/
static void
rtcp_send_rr(iptv_rtcp_info_t *info)
{
rtcp_rr_t report;
report.ssrc = htonl(info->source_ssrc);
// Fill in the extended last sequence
union {
uint16_t buffer[2];
uint32_t result;
} join2;
join2.buffer[0] = htons(info->sequence_cycle);
join2.buffer[1] = htons(info->last_received_sequence);
report.last_seq = join2.result;
// We don't compute this for now
report.fraction = 0;
report.lost = -1;
report.lsr = htonl(0);
report.dlsr = htonl(0);
// TODO: see how to put something meaningful
report.jitter = htonl(12);
// Build the full packet
rtcp_t packet;
packet.common.pt = RTCP_RR;
packet.common.count = 1;
// TODO : set the real length
packet.common.length = htons(7);
packet.r.rr.ssrc = htonl(info->my_ssrc);
packet.r.rr.rr[0] = report;
// Build the network packet
sbuf_t network_buffer;
sbuf_init(&network_buffer);
rtcp_append_headers(&network_buffer, &packet);
rtcp_append_rr(&network_buffer, &packet);
// Send it
rtcp_send(info, &network_buffer);
// TODO : send also the SDES CNAME packet
// Cleanup
sbuf_free(&network_buffer);
}
static void tr_de(char **args)
{
struct sbuf sbuf;
int id;
if (!args[1])
return;
id = map(args[1]);
sbuf_init(&sbuf);
if (args[0][1] == 'a' && args[0][2] == 'm' && str_get(id))
sbuf_append(&sbuf, str_get(id));
macrobody(&sbuf, args[2] ? args[2] : ".");
str_set(id, sbuf_buf(&sbuf));
sbuf_done(&sbuf);
if (!n_cp && args[3]) /* parse the arguments as request argv[3] */
str_dset(id, str_dget(map(args[3])));
}
static void tr_coi(char **args)
{
char *reg = args[1];
char *path = args[2];
char buf[1024];
FILE *fp;
if (!reg || !reg[0] || !path || !path[0])
return;
if ((fp = fopen(path + 1, "r"))) {
struct sbuf sb;
sbuf_init(&sb);
while (fgets(buf, sizeof(buf), fp))
sbuf_append(&sb, buf);
str_set(map(reg), sbuf_buf(&sb));
sbuf_done(&sb);
fclose(fp);
}
}
void cat(const char *filename)
{
FILE *fp;
char line[4096];
struct sbuf f;
sbuf_init(&f);
sbuf_cpy(&f, filename);
sbuf_expand_tilde(&f);
fp = fopen(f.buf, "r");
if (!fp)
goto cleanup;
while (fgets(line, sizeof(line), fp))
printf("%s", line);
printf("\n");
fclose(fp);
cleanup:
xfree(f.buf);
}
