static int dbg_proc_read(char *buffer, char **start, off_t offset,
int count, int *peof, void *dat)
{
printk("max up_task latency=%uus\n", up_max_latency);
dbgdump();
*peof = 1;
return 0;
}
/**
* ソケット送信
*
* @param[in] sock ソケット
* @return ステータス
*/
static st_client
send_sock(int sock)
{
int retval = 0; /* 戻り値 */
size_t length = 0; /* 長さ */
ssize_t slen = 0; /* 送信するバイト数 */
expr = _readline(stdin);
if (!expr)
return EX_ALLOC_ERR;
if (*expr == '\0') { /* 文字列長ゼロ */
memfree((void **)&expr, NULL);
return EX_EMPTY;
}
if (!strcmp((char *)expr, "quit") ||
!strcmp((char *)expr, "exit"))
return EX_QUIT;
length = strlen((char *)expr) + 1;
dbgdump(expr, length, "stdin: expr=%zu", length);
if (g_tflag)
start_timer(&start_time);
/* データ設定 */
slen = set_client_data(&sdata, expr, length);
if (slen < 0) /* メモリ確保できない */
return EX_ALLOC_ERR;
dbglog("slen=%zd", slen);
if (g_gflag)
outdump(sdata, slen, "send: sdata=%p, length=%zd", sdata, slen);
stddump(sdata, slen, "send: sdata=%p, length=%zd", sdata, slen);
/* データ送信 */
retval = send_data(sock, sdata, (size_t *)&slen);
if (retval < 0) /* エラー */
return EX_SEND_ERR;
memfree((void **)&expr, (void **)&sdata, NULL);
return EX_SUCCESS;
}
static int real_process_media_packet(struct stream_t *stream,uint8_t *header,
uint8_t *buffer,size_t max_size)
{
int ret = 0;
struct stream_ctrl_t *stream_ctrl = stream->stream_ctrl;
struct rmff_pheader_t ph = {0};
int size = 0;
int seq = 0;
int flags1 = 0,flags2 = 0;
uint32_t ts = 0;
if(header[0] != 0x24) {
display(MSDL_ERR,"wrong rdt magic : [0x%02x]\n",header[0]);
/* dump header*/
dbgdump(header,8);
display(MSDL_DBG,"\n");
goto failed;
}
size = (header[1] << 16) + (header[2] << 8) + header[3];
flags1 = header[4];
if((flags1!=0x40) && (flags1!=0x42)) {
display(MSDL_DBG,"wrong rdt flags1 : [0x%02x]\n",flags1);
if(header[6] == 0x06) {
display(MSDL_DBG,"got end of stream packet\n");
stream_ctrl->status = STREAMING_FINISHED;
return 0;
}
header[0] = header[5];
header[1] = header[6];
header[2] = header[7];
ret = read_data(stream,header + 3,5);
if(ret < 5) goto failed;
ret = read_data(stream,header + 4,4);
if(ret < 4) goto failed;
flags1 = header[4];
size -= 9;
}
flags2 = header[7];
seq = (header[5] << 8) + header[6];
ret = read_data(stream,header,6);
if(ret < 6) goto failed;
ts = get32_be(header);
stream_ctrl->packet_count++;
display(MSDL_DBG,"ts:%u size:%u, flags1:0x%02x, seq:%d, flags2:%x\n",
ts,size,flags1,seq,flags2);
size += 2;
ph.object_version = 0;
ph.length = size;
ph.stream_number = (flags1>>1) & 1;
ph.timestamp = ts;
ph.reserved = 0;
if((flags2 & 1) == 0 &&
(stream_ctrl->rtsp_ctrl->prev_ts != ts ||
stream_ctrl->rtsp_ctrl->prev_stream_number != ph.stream_number)) {
stream_ctrl->rtsp_ctrl->prev_ts = ts;
stream_ctrl->rtsp_ctrl->prev_stream_number = ph.stream_number;
ph.flags = 2;
}
else {
ph.flags = 0;
}
/*
* Keep Alive SET_PARAMETER
*/
/*if(!(stream_ctrl->packet_count % 200)) {
struct rtsp_header_t *rtsp_hdr;
rtsp_hdr = new_rtsp_header_with_standard_fields(stream_ctrl->rtsp_ctrl);
if(stream->dlopts->bandwidth) {
char *buffer = xmalloc(BUFSIZE_1K);
snprintf(buffer,BUFSIZE_1K - 1,
"SetDeliveryBandwidth: Bandwidth=%d;BackOff=0",stream->dlopts->bandwidth);
rtsp_set_field(rtsp_hdr,buffer);
free(buffer);
}
rtsp_request_set_parameter(rtsp_hdr,stream_ctrl->rtsp_ctrl->mrl);
rtsp_send_request_and_free(stream,rtsp_hdr);
}*/
/* if buffering, do special thing */
if(stream_ctrl->status == STREAMING_RESUME_BUFFERING) {
display(MSDL_DBG,
"target ts: %d [0x%x], current packet ts: %d [0x%x]\n",
stream_ctrl->rtsp_ctrl->resume_start_ts,
stream_ctrl->rtsp_ctrl->resume_start_ts,
ph.timestamp,ph.timestamp);
if(ph.timestamp == stream_ctrl->rtsp_ctrl->resume_start_ts) {
stream_ctrl->status = STREAMING_DOWNLOADING; /* fallthrouh */
}
else {
int ret = 0;
ret = read_data(stream,stream_ctrl->write_buffer,size - 12); /* trash data */
if(ret <= 0) goto failed;
return 0;
}
}
if(max_size > size) {
/* all data can go to buffer --> just do it!! */
rmff_dump_pheader(&ph,buffer);
size -= 12;
ret = read_data(stream,buffer + 12,size);
if(ret <= 0) goto failed;
return ret + 12;
}
else {
/*
buffer is not enough.. copy max_size data to
buffer and the rest goes to netsock->buffer.
*/
rmff_dump_pheader(&ph,stream_ctrl->write_buffer);
ret = read_data(stream,stream_ctrl->write_buffer + 12,size - 12);
if(ret <= 0) goto failed;
/*
it is guranteed that netsock->buffer is
empty when it comes here!
--> reset stream_ctrl->write_pos and so on...
*/
memcpy(buffer,stream_ctrl->write_buffer,max_size);
stream_ctrl->write_data_len = size - max_size;
stream_ctrl->write_pos = max_size;
return max_size;
}
failed:
return -1;
}
/**
* サーバプロセス
*
* @param[in] arg ソケットディスクリプタ
* @return 常にNULL
*/
static void *
server_proc(void *arg)
{
thread_data dt; /* スレッドデータ構造体 */
int retval = 0; /* 戻り値 */
size_t length = 0; /* 長さ */
ssize_t slen = 0; /* 送信するバイト数 */
struct header hd; /* ヘッダ構造体 */
unsigned char *expr = NULL; /* 受信データ */
calcinfo calc; /* calc情報構造体 */
struct server_data *sdata = NULL; /* 送信データ構造体 */
(void)memcpy(&dt, arg, sizeof(thread_data));
dbglog("start: accept=%d sin_addr=%s sin_port=%d, len=%d",
dt.sock, inet_ntoa(dt.addr.sin_addr),
ntohs(dt.addr.sin_port), dt.len);
/* シグナルマスクを設定 */
set_thread_sigmask(dt.sigmask);
pthread_cleanup_push(thread_cleanup, &dt);
do {
/* ヘッダ受信 */
length = sizeof(struct header);
(void)memset(&hd, 0, length);
retval = recv_data(dt.sock, &hd, &length);
if (retval < 0) /* エラーまたは接続先がシャットダウンされた */
pthread_exit((void *)EXIT_FAILURE);
dbglog("recv_data: hd=%p, length=%zu, hd.length=%zu",
&hd, length, hd.length);
if (g_gflag)
outdump(&hd, length, "recv: hd=%p, length=%zu", &hd, length);
stddump(&hd, length, "recv: hd=%p, length=%zu", &hd, length);
/* データ受信 */
length = (size_t)ntohl((uint32_t)hd.length); /* データ長を保持 */
expr = (unsigned char *)recv_data_new(dt.sock, &length);
if (!expr) /* メモリ不足 */
pthread_exit((void *)EXIT_FAILURE);
pthread_cleanup_push(thread_memfree, &expr);
if (!length) /* 受信エラー */
pthread_exit((void *)EXIT_FAILURE);
dbglog("expr=%p, length=%zu", expr, length);
if (g_gflag)
outdump(expr, length,
"recv: expr=%p, length=%zu", expr, length);
stddump(expr, length,
"recv: expr=%p, length=%zu", expr, length);
/* サーバ処理 */
(void)memset(&calc, 0, sizeof(calcinfo));
if (!create_answer(&calc, expr))
pthread_exit((void *)EXIT_FAILURE);
pthread_cleanup_push(destroy_answer, &calc);
length = strlen((char *)calc.answer) + 1; /* 文字列長保持 */
dbgdump(calc.answer, length,
"answer=%p, length=%zu", calc.answer, length);
/* データ送信 */
slen = set_server_data(&sdata, calc.answer, length);
if (slen < 0) /* メモリ確保できない */
pthread_exit((void *)EXIT_FAILURE);
pthread_cleanup_push(thread_memfree, &sdata);
dbglog("slen=%zd", slen);
if (g_gflag)
outdump(sdata, slen,
"send: sdata=%p, slen=%zd", sdata, slen);
stddump(sdata, slen,
"send: sdata=%p, slen=%zd", sdata, slen);
retval = send_data(dt.sock, sdata, (size_t *)&slen);
if (retval < 0) /* エラー */
pthread_exit((void *)EXIT_FAILURE);
dbglog("send_data: sdata=%p, slen=%zu", sdata, slen);
pthread_cleanup_pop(1);
pthread_cleanup_pop(1);
pthread_cleanup_pop(1);
} while (!g_sig_handled);
pthread_cleanup_pop(1);
pthread_exit((void *)EXIT_SUCCESS);
return (void *)EXIT_SUCCESS;
}
