static int msm_pcm_prepare(struct snd_pcm_substream *substream)
{
int ret = 0;
struct snd_pcm_runtime *runtime = substream->runtime;
struct msm_voice *prtd = runtime->private_data;
uint32_t session_id = 0;
mutex_lock(&prtd->lock);
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
ret = msm_pcm_playback_prepare(substream);
else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
ret = msm_pcm_capture_prepare(substream);
if (prtd->playback_start && prtd->capture_start) {
session_id = get_session_id(prtd);
if (session_id)
voc_start_voice_call(session_id);
}
mutex_unlock(&prtd->lock);
return ret;
}
int set_table_ctrl_analog_state (saHpiCtrlAnalogTable_context *row_ctx)
{
DEBUGMSGTL ((AGENT, "set_table_ctrl_analog_state, called\n"));
SaErrorT rc = SA_OK;
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiCtrlStateT ctrl_state;
if (!row_ctx)
return AGENT_ERR_NULL_DATA;
session_id = get_session_id(row_ctx->index.oids[saHpiDomainId_INDEX]);
resource_id = row_ctx->index.oids[saHpiResourceEntryId_INDEX];
ctrl_state.StateUnion.Analog = row_ctx->saHpiCtrlAnalogState;
ctrl_state.Type = SAHPI_CTRL_TYPE_ANALOG;
rc = saHpiControlSet(session_id, resource_id,
row_ctx->saHpiCtrlAnalogNum,
row_ctx->saHpiCtrlAnalogMode - 1,
&ctrl_state);
if (rc != SA_OK) {
snmp_log (LOG_ERR,
"SAHPI_CTRL_TYPE_ANALOG: Call to saHpiControlSet failed to set State rc: %s.\n",
oh_lookup_error(rc));
DEBUGMSGTL ((AGENT,
"SAHPI_CTRL_TYPE_ANALOG: Call to saHpiControlSet failed to set State rc: %s.\n",
oh_lookup_error(rc)));
return get_snmp_error(rc);
}
return SNMP_ERR_NOERROR;
}
int
main(int argc, char **argv)
{
const int exit_sig[] = {SIGINT, SIGTERM, SIGHUP};
char *fqdn = NULL;
struct passwd *passwd;
struct tlog_writer *writer = NULL;
clockid_t clock_id;
struct timespec timestamp;
struct tlog_sink *sink = NULL;
tlog_grc grc;
ssize_t rc;
int master_fd;
pid_t child_pid;
unsigned int session_id;
sig_atomic_t last_sigwinch_caught = 0;
sig_atomic_t new_sigwinch_caught;
sig_atomic_t last_alarm_caught = 0;
sig_atomic_t new_alarm_caught;
bool alarm_set = false;
bool io_pending = false;
bool term_attrs_set = false;
struct termios orig_termios;
struct termios raw_termios;
struct winsize winsize;
struct winsize new_winsize;
size_t i, j;
struct sigaction sa;
struct pollfd fds[FD_IDX_NUM];
uint8_t input_buf[BUF_SIZE];
size_t input_pos = 0;
size_t input_len = 0;
uint8_t output_buf[BUF_SIZE];
size_t output_pos = 0;
size_t output_len = 0;
struct tlog_pkt pkt = TLOG_PKT_VOID;
int status = 1;
(void)argv;
if (argc > 1) {
fprintf(stderr, "Arguments are not accepted\n");
goto cleanup;
}
/* Get host FQDN */
grc = get_fqdn(&fqdn);
if (grc != TLOG_RC_OK) {
fprintf(stderr, "Failed retrieving host FQDN: %s\n",
tlog_grc_strerror(grc));
goto cleanup;
}
/* Get session ID */
grc = get_session_id(&session_id);
if (grc != TLOG_RC_OK) {
fprintf(stderr, "Failed retrieving session ID: %s\n",
tlog_grc_strerror(grc));
goto cleanup;
}
/* Open syslog */
openlog("tlog", LOG_NDELAY, LOG_LOCAL0);
/* Create the syslog writer */
grc = tlog_syslog_writer_create(&writer, LOG_INFO);
if (grc != TLOG_RC_OK) {
fprintf(stderr, "Failed creating syslog writer: %s\n",
tlog_grc_strerror(grc));
goto cleanup;
}
/* Get effective user entry */
errno = 0;
passwd = getpwuid(geteuid());
if (passwd == NULL) {
if (errno == 0)
fprintf(stderr, "User entry not found\n");
else
fprintf(stderr, "Failed retrieving user entry: %s\n",
strerror(errno));
goto cleanup;
}
/*
* Choose the clock: try to use coarse monotonic clock (which is faster),
* if it provides resolution of at least one millisecond.
*/
if (clock_getres(CLOCK_MONOTONIC_COARSE, ×tamp) == 0 &&
timestamp.tv_sec == 0 && timestamp.tv_nsec < 1000000) {
clock_id = CLOCK_MONOTONIC_COARSE;
} else if (clock_getres(CLOCK_MONOTONIC, NULL) == 0) {
clock_id = CLOCK_MONOTONIC;
} else {
fprintf(stderr, "No clock to use\n");
goto cleanup;
}
/* Create the log sink */
grc = tlog_sink_create(&sink, writer, fqdn, passwd->pw_name,
session_id, BUF_SIZE);
if (grc != TLOG_RC_OK) {
fprintf(stderr, "Failed creating log sink: %s\n",
tlog_grc_strerror(grc));
goto cleanup;
}
/* Get terminal attributes */
rc = tcgetattr(STDOUT_FILENO, &orig_termios);
if (rc < 0) {
fprintf(stderr, "Failed retrieving tty attributes: %s\n",
strerror(errno));
goto cleanup;
}
/* Get terminal window size */
rc = ioctl(STDOUT_FILENO, TIOCGWINSZ, &winsize);
if (rc < 0) {
fprintf(stderr, "Failed retrieving tty window size: %s\n",
strerror(errno));
goto cleanup;
}
/* Fork a child under a slave pty */
child_pid = forkpty(&master_fd, NULL, &orig_termios, &winsize);
if (child_pid < 0) {
fprintf(stderr, "Failed forking a pty: %s\n", strerror(errno));
goto cleanup;
} else if (child_pid == 0) {
/*
* Child
*/
execl("/bin/bash", "/bin/bash", NULL);
fprintf(stderr, "Failed to execute the shell: %s",
strerror(errno));
goto cleanup;
}
/*
* Parent
*/
/* Log initial window size */
clock_gettime(clock_id, ×tamp);
tlog_pkt_init_window(&pkt, ×tamp,
winsize.ws_col, winsize.ws_row);
grc = tlog_sink_write(sink, &pkt);
tlog_pkt_cleanup(&pkt);
if (grc != TLOG_RC_OK) {
fprintf(stderr, "Failed logging window size: %s\n",
tlog_grc_strerror(grc));
goto cleanup;
}
/* Setup signal handlers to terminate gracefully */
for (i = 0; i < ARRAY_SIZE(exit_sig); i++) {
sigaction(exit_sig[i], NULL, &sa);
if (sa.sa_handler != SIG_IGN)
{
sa.sa_handler = exit_sighandler;
sigemptyset(&sa.sa_mask);
for (j = 0; j < ARRAY_SIZE(exit_sig); j++)
sigaddset(&sa.sa_mask, exit_sig[j]);
/* NOTE: no SA_RESTART on purpose */
sa.sa_flags = 0;
sigaction(exit_sig[i], &sa, NULL);
}
}
/* Setup WINCH signal handler */
sa.sa_handler = winch_sighandler;
sigemptyset(&sa.sa_mask);
/* NOTE: no SA_RESTART on purpose */
sa.sa_flags = 0;
sigaction(SIGWINCH, &sa, NULL);
/* Setup ALRM signal handler */
sa.sa_handler = alarm_sighandler;
sigemptyset(&sa.sa_mask);
/* NOTE: no SA_RESTART on purpose */
sa.sa_flags = 0;
sigaction(SIGALRM, &sa, NULL);
/* Switch the terminal to raw mode */
raw_termios = orig_termios;
raw_termios.c_lflag &= ~(ICANON | ISIG | IEXTEN | ECHO);
raw_termios.c_iflag &= ~(BRKINT | ICRNL | IGNBRK | IGNCR | INLCR |
INPCK | ISTRIP | IXON | PARMRK);
raw_termios.c_oflag &= ~OPOST;
raw_termios.c_cc[VMIN] = 1;
raw_termios.c_cc[VTIME] = 0;
rc = tcsetattr(STDOUT_FILENO, TCSAFLUSH, &raw_termios);
if (rc < 0) {
fprintf(stderr, "Failed setting tty attributes: %s\n",
strerror(errno));
goto cleanup;
}
term_attrs_set = true;
/*
* Transfer I/O and window changes
*/
fds[FD_IDX_STDIN].fd = STDIN_FILENO;
fds[FD_IDX_STDIN].events = POLLIN;
fds[FD_IDX_MASTER].fd = master_fd;
fds[FD_IDX_MASTER].events = POLLIN;
while (exit_signum == 0) {
/*
* Handle SIGWINCH
*/
new_sigwinch_caught = sigwinch_caught;
if (new_sigwinch_caught != last_sigwinch_caught) {
/* Retrieve window size */
rc = ioctl(STDOUT_FILENO, TIOCGWINSZ, &new_winsize);
if (rc < 0) {
if (errno == EBADF)
status = 0;
else
fprintf(stderr, "Failed retrieving window size: %s\n",
strerror(errno));
break;
}
/* If window size has changed */
if (new_winsize.ws_row != winsize.ws_row ||
new_winsize.ws_col != winsize.ws_col) {
/* Log window size */
clock_gettime(clock_id, ×tamp);
tlog_pkt_init_window(&pkt, ×tamp,
new_winsize.ws_col,
new_winsize.ws_row);
grc = tlog_sink_write(sink, &pkt);
tlog_pkt_cleanup(&pkt);
if (grc != TLOG_RC_OK) {
fprintf(stderr, "Failed logging window size: %s\n",
tlog_grc_strerror(grc));
break;
}
/* Propagate window size */
rc = ioctl(master_fd, TIOCSWINSZ, &new_winsize);
if (rc < 0) {
if (errno == EBADF)
status = 0;
else
fprintf(stderr, "Failed setting window size: %s\n",
strerror(errno));
break;
}
winsize = new_winsize;
}
/* Mark SIGWINCH processed */
last_sigwinch_caught = new_sigwinch_caught;
}
/*
* Deliver I/O
*/
clock_gettime(clock_id, ×tamp);
if (input_pos < input_len) {
rc = write(master_fd, input_buf + input_pos,
input_len - input_pos);
if (rc >= 0) {
if (rc > 0) {
/* Log delivered input */
tlog_pkt_init_io(&pkt, ×tamp,
false, input_buf + input_pos,
false, (size_t)rc);
grc = tlog_sink_write(sink, &pkt);
tlog_pkt_cleanup(&pkt);
if (grc != TLOG_RC_OK) {
fprintf(stderr, "Failed logging input: %s\n",
tlog_grc_strerror(grc));
break;
}
io_pending = true;
input_pos += rc;
}
/* If interrupted by a signal handler */
if (input_pos < input_len)
continue;
/* Exhausted */
input_pos = input_len = 0;
} else {
if (errno == EINTR)
continue;
else if (errno == EBADF || errno == EINVAL)
status = 0;
else
fprintf(stderr, "Failed to write to master: %s\n",
strerror(errno));
break;
};
}
if (output_pos < output_len) {
rc = write(STDOUT_FILENO, output_buf + output_pos,
output_len - output_pos);
if (rc >= 0) {
if (rc > 0) {
/* Log delivered output */
tlog_pkt_init_io(&pkt, ×tamp,
true, output_buf + output_pos,
false, (size_t)rc);
grc = tlog_sink_write(sink, &pkt);
tlog_pkt_cleanup(&pkt);
if (grc != TLOG_RC_OK) {
fprintf(stderr, "Failed logging output: %s\n",
tlog_grc_strerror(grc));
break;
}
io_pending = true;
output_pos += rc;
}
/* If interrupted by a signal handler */
if (output_pos < output_len)
continue;
/* Exhausted */
output_pos = output_len = 0;
} else {
if (errno == EINTR)
continue;
else if (errno == EBADF || errno == EINVAL)
status = 0;
else
fprintf(stderr, "Failed to write to stdout: %s\n",
strerror(errno));
break;
};
}
/*
* Handle I/O latency limit
*/
new_alarm_caught = alarm_caught;
if (new_alarm_caught != last_alarm_caught) {
alarm_set = false;
grc = tlog_sink_flush(sink);
if (grc != TLOG_RC_OK) {
fprintf(stderr, "Failed flushing I/O log: %s\n",
tlog_grc_strerror(grc));
goto cleanup;
}
last_alarm_caught = new_alarm_caught;
io_pending = false;
} else if (io_pending && !alarm_set) {
alarm(IO_LATENCY);
alarm_set = true;
}
/*
* Wait for I/O
*/
rc = poll(fds, sizeof(fds) / sizeof(fds[0]), -1);
if (rc < 0) {
if (errno == EINTR)
continue;
else
fprintf(stderr, "Failed waiting for I/O: %s\n",
strerror(errno));
break;
}
/*
* Retrieve I/O
*
* NOTE: Reading master first in case child went away.
* Otherwise writing to it can block
*/
if (fds[FD_IDX_MASTER].revents & (POLLIN | POLLHUP | POLLERR)) {
rc = read(master_fd, output_buf, sizeof(output_buf));
if (rc <= 0) {
if (rc < 0 && errno == EINTR)
continue;
status = 0;
break;
}
output_len = rc;
}
if (fds[FD_IDX_STDIN].revents & (POLLIN | POLLHUP | POLLERR)) {
rc = read(STDIN_FILENO, input_buf, sizeof(input_buf));
if (rc <= 0) {
if (rc < 0 && errno == EINTR)
continue;
status = 0;
break;
}
input_len = rc;
}
}
/* Cut I/O log (write incomplete characters as binary) */
grc = tlog_sink_cut(sink);
if (grc != TLOG_RC_OK) {
fprintf(stderr, "Failed cutting-off I/O log: %s\n",
tlog_grc_strerror(grc));
goto cleanup;
}
/* Flush I/O log */
grc = tlog_sink_flush(sink);
if (grc != TLOG_RC_OK) {
fprintf(stderr, "Failed flushing I/O log: %s\n",
tlog_grc_strerror(grc));
goto cleanup;
}
cleanup:
tlog_sink_destroy(sink);
tlog_writer_destroy(writer);
free(fqdn);
/* Restore signal handlers */
for (i = 0; i < ARRAY_SIZE(exit_sig); i++) {
sigaction(exit_sig[i], NULL, &sa);
if (sa.sa_handler != SIG_IGN)
signal(exit_sig[i], SIG_DFL);
}
/* Restore terminal attributes */
if (term_attrs_set) {
rc = tcsetattr(STDOUT_FILENO, TCSAFLUSH, &orig_termios);
if (rc < 0 && errno != EBADF) {
fprintf(stderr, "Failed restoring tty attributes: %s\n",
strerror(errno));
return 1;
}
}
/* Reproduce the exit signal to get proper exit status */
if (exit_signum != 0)
raise(exit_signum);
return status;
}
static int erspan_rcv(struct sk_buff *skb, struct tnl_ptk_info *tpi,
int gre_hdr_len)
{
struct net *net = dev_net(skb->dev);
struct metadata_dst *tun_dst = NULL;
struct erspan_base_hdr *ershdr;
struct erspan_metadata *pkt_md;
struct ip_tunnel_net *itn;
struct ip_tunnel *tunnel;
const struct iphdr *iph;
struct erspan_md2 *md2;
int ver;
int len;
itn = net_generic(net, erspan_net_id);
len = gre_hdr_len + sizeof(*ershdr);
/* Check based hdr len */
if (unlikely(!pskb_may_pull(skb, len)))
return PACKET_REJECT;
iph = ip_hdr(skb);
ershdr = (struct erspan_base_hdr *)(skb->data + gre_hdr_len);
ver = ershdr->ver;
/* The original GRE header does not have key field,
* Use ERSPAN 10-bit session ID as key.
*/
tpi->key = cpu_to_be32(get_session_id(ershdr));
tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex,
tpi->flags,
iph->saddr, iph->daddr, tpi->key);
if (tunnel) {
len = gre_hdr_len + erspan_hdr_len(ver);
if (unlikely(!pskb_may_pull(skb, len)))
return PACKET_REJECT;
ershdr = (struct erspan_base_hdr *)skb->data;
pkt_md = (struct erspan_metadata *)(ershdr + 1);
if (__iptunnel_pull_header(skb,
len,
htons(ETH_P_TEB),
false, false) < 0)
goto drop;
if (tunnel->collect_md) {
struct ip_tunnel_info *info;
struct erspan_metadata *md;
__be64 tun_id;
__be16 flags;
tpi->flags |= TUNNEL_KEY;
flags = tpi->flags;
tun_id = key32_to_tunnel_id(tpi->key);
tun_dst = rpl_ip_tun_rx_dst(skb, flags, tun_id, sizeof(*md));
if (!tun_dst)
return PACKET_REJECT;
md = ip_tunnel_info_opts(&tun_dst->u.tun_info);
md->version = ver;
md2 = &md->u.md2;
memcpy(md2, pkt_md, ver == 1 ? ERSPAN_V1_MDSIZE :
ERSPAN_V2_MDSIZE);
info = &tun_dst->u.tun_info;
info->key.tun_flags |= TUNNEL_ERSPAN_OPT;
info->options_len = sizeof(*md);
}
skb_reset_mac_header(skb);
ovs_ip_tunnel_rcv(tunnel->dev, skb, tun_dst);
kfree(tun_dst);
return PACKET_RCVD;
}
drop:
kfree_skb(skb);
return PACKET_RCVD;
}
int
read_rtsp (sockets * s)
{
char *arg[50];
int cseq, la, i, rlen;
char *proto, *transport = NULL, *useragent = NULL;
int sess_id = 0;
char buf[2000];
streams *sid = get_sid(s->sid);
if(s->buf[0]==0x24 && s->buf[1]<2)
{
if(sid)
sid->rtime = s->rtime;
int rtsp_len = s->buf[2]*256+s->buf[3];
LOG("Received RTSP over tcp packet (sock_id %d, stream %d, rlen %d) packet len: %d, type %02X %02X discarding %s...",
s->id, s->sid, s->rlen, rtsp_len , s->buf[4], s->buf[5], (s->rlen == rtsp_len+4)?"complete":"fragment" );
if(s->rlen == rtsp_len+4){ // we did not receive the entire packet
s->rlen = 0;
return 0;
}
}
if (s->rlen < 4 || !end_of_header(s->buf + s->rlen - 4))
{
if( s->rlen > RBUF - 10 )
{
LOG("Discarding %d bytes from the socket buffer, request > %d, consider increasing RBUF", s->rlen, RBUF);
s->rlen = 0;
}
LOG("read_rtsp: read %d bytes from handle %d, sock_id %d, flags %d not ending with \\r\\n\\r\\n", s->rlen, s->sock, s->id, s->flags);
if ( s->flags & 1 )
return 0;
unsigned char *new_alloc = malloc1 (RBUF);
memcpy(new_alloc, s->buf, s->rlen);
s->buf = new_alloc;
s->flags = s->flags | 1;
return 0;
}
rlen = s->rlen;
s->rlen = 0;
LOG ("read RTSP (from handle %d sock_id %d, len: %d, sid %d):\n%s", s->sock, s->id, s->rlen, s->sid, s->buf);
if( (s->type != TYPE_HTTP ) && (strncasecmp(s->buf, "GET", 3) == 0))
{
http_response (s , 404, NULL, NULL, 0, 0);
return 0;
}
la = split (arg, s->buf, 50, ' ');
cseq = 0;
if (la<2)
LOG_AND_RETURN(0, "Most likely not an RTSP packet sock_id: %d sid: %d rlen: %d, dropping ....", s->id, s->sid, rlen);
if(s->sid<0)
for (i = 0; i < la; i++)
if (strncasecmp ("Session:", arg[i], 8) == 0)
{
sess_id = map_int(header_parameter(arg, i), NULL);
s->sid = find_session_id(sess_id);
}
if(strstr(arg[1], "freq") || strstr(arg[1], "pids"))
{
int old_sid = s->sid;
sid = (streams *) setup_stream (arg[1], s);
}
sid = get_sid(s->sid);
if(sid)
sid->rtime = s->rtime;
if (sess_id)
set_session_id(s->sid, sess_id);
for (i = 0; i < la; i++)
if (strncasecmp ("CSeq:", arg[i], 5) == 0)
cseq = map_int (header_parameter(arg, i), NULL);
else if (strncasecmp ("Transport:", arg[i], 9) == 0){
transport = header_parameter(arg, i);
if( -1 == decode_transport (s, transport, opts.rrtp, opts.start_rtp))
{
http_response (s, 400, NULL, NULL, cseq, 0);
return 0;
}
}
else if (strstr (arg[i], "LIVE555"))
{
if(sid) sid->timeout = 0;
}
else if (strstr (arg[i], "Lavf"))
{
if(sid) sid->timeout = 0;
}
else if (strncasecmp ("User-Agent:", arg[i], 10) == 0)
useragent = header_parameter(arg, i);
if((strncasecmp (arg[0], "PLAY", 4) == 0) || (strncasecmp (arg[0], "GET", 3) == 0) || (strncasecmp (arg[0], "SETUP", 5) == 0))
{
char ra[100];
int rv;
if (!( sid = get_sid(s->sid)))
{
http_response (s, 454, NULL, NULL, cseq, 0);
return 0;
}
if (useragent)
strncpy(sid->useragent, useragent, 127);
if ((strncasecmp (arg[0], "PLAY", 3) == 0) || (strncasecmp (arg[0], "GET", 3) == 0))
if ((rv = start_play (sid, s)) < 0)
{
http_response (s, -rv , NULL, NULL, cseq, 0);
return 0;
}
strcpy(ra, inet_ntoa (sid->sa.sin_addr));
buf[0] = 0;
if(transport)
{
int s_timeout = (sid->timeout ? sid->timeout : opts.timeout_sec) / 1000;
switch (sid->type)
{
case STREAM_RTSP_UDP:
if (atoi (ra) < 239)
snprintf (buf, sizeof(buf), "Transport: RTP/AVP;unicast;destination=%s;source=%s;client_port=%d-%d;server_port=%d-%d\r\nSession: %010d;timeout=%d\r\ncom.ses.streamID: %d",
ra, get_sock_host (s->sock), ntohs (sid->sa.sin_port), ntohs (sid->sa.sin_port) + 1,
// opts.start_rtp, opts.start_rtp + 1,
get_sock_port(sid->rsock), get_sock_port(sid->rtcp),
get_session_id (s->sid), s_timeout, sid->sid + 1);
else
snprintf (buf, sizeof(buf), "Transport: RTP/AVP;multicast;destination=%s;port=%d-%d\r\nSession: %010d;timeout=%d\r\ncom.ses.streamID: %d",
ra, ntohs (sid->sa.sin_port), ntohs (sid->sa.sin_port) + 1,
get_session_id (s->sid), s_timeout , sid->sid + 1);
break;
case STREAM_RTSP_TCP:
snprintf(buf, sizeof(buf), "Transport: RTP/AVP/TCP;interleaved=0-1\r\nSession: %010d;timeout=%d\r\ncom.ses.streamID: %d",
get_session_id (s->sid), s_timeout, sid->sid + 1);
break;
}
}
if (strncasecmp(arg[0], "PLAY", 4) == 0)
{
char *qm = strchr(arg[1], '?');
if(qm)
*qm = 0;
if(buf[0])
strcat(buf, "\r\n");
snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf) - 1, "RTP-Info: url=%s;seq=%d;rtptime=%lld\r\nRange: npt=0.000-", arg[1], getTick(),(long long int)(getTickUs()/1000000));
}
if(buf[0]==0 && sid->type == STREAM_HTTP)
snprintf(buf, sizeof(buf), "Content-Type: video/mp2t");
http_response (s, 200, buf, NULL, cseq, 0);
}
else if (strncmp (arg[0], "TEARDOWN", 8) == 0)
{
streams *sid;
buf[0] = 0;
if(get_sid(s->sid))
sprintf(buf, "Session: %010d", get_session_id(s->sid));
close_stream (s->sid);
http_response (s, 200, buf, NULL, cseq, 0);
}
else
{
if (strncmp (arg[0], "DESCRIBE", 8) == 0)
{
char sbuf[1000];
char *rv = NULL;
rv = describe_streams(s, arg[1], sbuf, sizeof(sbuf));
if (! rv)
{
http_response (s, 404, NULL, NULL, cseq, 0);
return 0;
}
snprintf(buf, sizeof(buf), "Content-type: application/sdp\r\nContent-Base: rtsp://%s/", get_sock_host(s->sock));
http_response (s, 200, buf, sbuf, cseq, 0);
}
else if (strncmp (arg[0], "OPTIONS", 8) == 0)
{
http_response (s, 200, public, NULL, cseq, 0);
}
}
static gpointer event_thread_loop(gpointer data)
{
SaErrorT rv;
SaHpiEventT event;
SaHpiRdrT rdr;
SaHpiRptEntryT rpt_entry;
SaHpiEvtQueueStatusT event_queue_status;
int counter = 0;
SaHpiSessionIdT sessionid = *(SaHpiSessionIdT *)data;
while(get_run_threaded()) {
memset(&event, 0, sizeof(event));
DEBUGMSGTL ((AGENT, "event_thread_loop started ---- sessionid [%d]\n", sessionid));
rv = saHpiEventGet (get_session_id(SAHPI_UNSPECIFIED_DOMAIN_ID),
timeout,
&event,
&rdr,
&rpt_entry,
&event_queue_status);
DEBUGMSGTL ((AGENT, "rv [%s]\n", oh_lookup_error(rv)));
counter++;
/* serialize access */
g_mutex_lock(thread_mutex);
if (rv == SA_OK) { // NEW
DEBUGMSGTL ((AGENT, "Event Type [%s]\n",
oh_lookup_eventtype(event.EventType)));
oh_print_event(&event, 0);
switch (event.EventType) {
case SAHPI_ET_RESOURCE:
DEBUGMSGTL ((AGENT, "SAHPI_ET_RESOURCE, [%s]\n",
oh_lookup_resourceeventtype(
event.EventDataUnion.ResourceEvent.ResourceEventType)));
break;
case SAHPI_ET_DOMAIN:
DEBUGMSGTL ((AGENT, "SAHPI_ET_DOMAIN, [%s]\n",
oh_lookup_domaineventtype(
event.EventDataUnion.DomainEvent.Type)));
break;
case SAHPI_ET_SENSOR:
break;
case SAHPI_ET_SENSOR_ENABLE_CHANGE:
break;
case SAHPI_ET_HOTSWAP:
break;
case SAHPI_ET_WATCHDOG:
break;
case SAHPI_ET_HPI_SW:
DEBUGMSGTL ((AGENT, "SAHPI_ET_HPI_SW, [%s]\n",
oh_lookup_sweventtype(
event.EventDataUnion.HpiSwEvent.Type)));
break;
case SAHPI_ET_OEM:
DEBUGMSGTL ((AGENT, "SAHPI_ET_HPI_SW, [%s]\n",
oh_lookup_sweventtype(
event.EventDataUnion.HpiSwEvent.Type)));
break;
case SAHPI_ET_USER:
break;
default:
break;
}
rv = async_event_add(sessionid, &event, &rdr, &rpt_entry);
} // NEW
/* serialize access */
// Now check for updates to the event logs
rv = event_log_info_update(sessionid);
if (rediscover == SAHPI_TRUE)
{
repopulate_tables(get_session_id(SAHPI_UNSPECIFIED_DOMAIN_ID));
rediscover = SAHPI_FALSE;
}
if (counter == 30) { //check for new announcements every minute.
update_announcements(get_session_id(SAHPI_UNSPECIFIED_DOMAIN_ID));
counter = 0;
}
g_mutex_unlock(thread_mutex);
}
g_thread_exit(0);
return data;
}
/**
* Create the log sink according to configuration.
*
* @param psink Location for the created sink pointer.
* @param conf Configuration JSON object.
*
* @return Global return code.
*/
static tlog_grc
create_log_sink(struct tlog_sink **psink, struct json_object *conf)
{
tlog_grc grc;
int64_t num;
const char *str;
struct json_object *obj;
struct tlog_sink *sink = NULL;
struct tlog_json_writer *writer = NULL;
int fd = -1;
char *fqdn = NULL;
struct passwd *passwd;
unsigned int session_id;
/*
* Create the writer
*/
if (!json_object_object_get_ex(conf, "writer", &obj)) {
fprintf(stderr, "Writer type is not specified\n");
grc = TLOG_RC_FAILURE;
goto cleanup;
}
str = json_object_get_string(obj);
if (strcmp(str, "file") == 0) {
struct json_object *conf_file;
/* Get file writer conf container */
if (!json_object_object_get_ex(conf, "file", &conf_file)) {
fprintf(stderr, "File writer parameters are not specified\n");
grc = TLOG_RC_FAILURE;
goto cleanup;
}
/* Get the file path */
if (!json_object_object_get_ex(conf_file, "path", &obj)) {
fprintf(stderr, "Log file path is not specified\n");
grc = TLOG_RC_FAILURE;
goto cleanup;
}
str = json_object_get_string(obj);
/* Open the file */
fd = open(str, O_WRONLY | O_CREAT | O_APPEND, S_IRWXU | S_IRWXG);
if (fd < 0) {
grc = TLOG_GRC_ERRNO;
fprintf(stderr, "Failed opening log file \"%s\": %s\n",
str, tlog_grc_strerror(grc));
goto cleanup;
}
/* Create the writer, letting it take over the FD */
grc = tlog_fd_json_writer_create(&writer, fd, true);
if (grc != TLOG_RC_OK) {
fprintf(stderr, "Failed creating file writer: %s\n",
tlog_grc_strerror(grc));
goto cleanup;
}
fd = -1;
} else if (strcmp(str, "syslog") == 0) {
struct json_object *conf_syslog;
int facility;
int priority;
/* Get syslog writer conf container */
if (!json_object_object_get_ex(conf, "syslog", &conf_syslog)) {
fprintf(stderr, "Syslog writer parameters are not specified\n");
grc = TLOG_RC_FAILURE;
goto cleanup;
}
/* Get facility */
if (!json_object_object_get_ex(conf_syslog, "facility", &obj)) {
fprintf(stderr, "Syslog facility is not specified\n");
grc = TLOG_RC_FAILURE;
goto cleanup;
}
str = json_object_get_string(obj);
facility = tlog_syslog_facility_from_str(str);
if (facility < 0) {
fprintf(stderr, "Unknown syslog facility: %s\n", str);
grc = TLOG_RC_FAILURE;
goto cleanup;
}
/* Get priority */
if (!json_object_object_get_ex(conf_syslog, "priority", &obj)) {
fprintf(stderr, "Syslog priority is not specified\n");
grc = TLOG_RC_FAILURE;
goto cleanup;
}
str = json_object_get_string(obj);
priority = tlog_syslog_priority_from_str(str);
if (priority < 0) {
fprintf(stderr, "Unknown syslog priority: %s\n", str);
grc = TLOG_RC_FAILURE;
goto cleanup;
}
/* Create the writer */
openlog("tlog", LOG_NDELAY, facility);
grc = tlog_syslog_json_writer_create(&writer, priority);
if (grc != TLOG_RC_OK) {
fprintf(stderr, "Failed creating syslog writer: %s\n",
tlog_grc_strerror(grc));
goto cleanup;
}
} else {
fprintf(stderr, "Unknown writer type: %s\n", str);
grc = TLOG_RC_FAILURE;
goto cleanup;
}
/*
* Create the sink
*/
/* Get host FQDN */
grc = get_fqdn(&fqdn);
if (grc != TLOG_RC_OK) {
fprintf(stderr, "Failed retrieving host FQDN: %s\n",
tlog_grc_strerror(grc));
goto cleanup;
}
/* Get session ID */
grc = get_session_id(&session_id);
if (grc != TLOG_RC_OK) {
fprintf(stderr, "Failed retrieving session ID: %s\n",
tlog_grc_strerror(grc));
goto cleanup;
}
/* Get effective user entry */
errno = 0;
passwd = getpwuid(geteuid());
if (passwd == NULL) {
if (errno == 0) {
grc = TLOG_RC_FAILURE;
fprintf(stderr, "User entry not found\n");
} else {
grc = TLOG_GRC_ERRNO;
fprintf(stderr, "Failed retrieving user entry: %s\n",
tlog_grc_strerror(grc));
}
goto cleanup;
}
/* Get the maximum payload size */
if (!json_object_object_get_ex(conf, "payload", &obj)) {
fprintf(stderr, "Maximum payload size is not specified\n");
grc = TLOG_RC_FAILURE;
goto cleanup;
}
num = json_object_get_int64(obj);
/* Create the sink, letting it take over the writer */
grc = tlog_json_sink_create(&sink, writer, true,
fqdn, passwd->pw_name,
session_id, (size_t)num);
if (grc != TLOG_RC_OK) {
fprintf(stderr, "Failed creating log sink: %s\n",
tlog_grc_strerror(grc));
goto cleanup;
}
writer = NULL;
*psink = sink;
sink = NULL;
grc = TLOG_RC_OK;
cleanup:
if (fd >= 0) {
close(fd);
}
tlog_json_writer_destroy(writer);
free(fqdn);
tlog_sink_destroy(sink);
return grc;
}
/* Fills in tpi and returns header length to be pulled. */
int gre_parse_header(struct sk_buff *skb, struct tnl_ptk_info *tpi,
bool *csum_err, __be16 proto, int nhs)
{
const struct gre_base_hdr *greh;
__be32 *options;
int hdr_len;
if (unlikely(!pskb_may_pull(skb, nhs + sizeof(struct gre_base_hdr))))
return -EINVAL;
greh = (struct gre_base_hdr *)(skb->data + nhs);
if (unlikely(greh->flags & (GRE_VERSION | GRE_ROUTING)))
return -EINVAL;
tpi->flags = gre_flags_to_tnl_flags(greh->flags);
hdr_len = gre_calc_hlen(tpi->flags);
if (!pskb_may_pull(skb, nhs + hdr_len))
return -EINVAL;
greh = (struct gre_base_hdr *)(skb->data + nhs);
tpi->proto = greh->protocol;
options = (__be32 *)(greh + 1);
if (greh->flags & GRE_CSUM) {
if (!skb_checksum_simple_validate(skb)) {
skb_checksum_try_convert(skb, IPPROTO_GRE, 0,
null_compute_pseudo);
} else if (csum_err) {
*csum_err = true;
return -EINVAL;
}
options++;
}
if (greh->flags & GRE_KEY) {
tpi->key = *options;
options++;
} else {
tpi->key = 0;
}
if (unlikely(greh->flags & GRE_SEQ)) {
tpi->seq = *options;
options++;
} else {
tpi->seq = 0;
}
/* WCCP version 1 and 2 protocol decoding.
* - Change protocol to IPv4/IPv6
* - When dealing with WCCPv2, Skip extra 4 bytes in GRE header
*/
if (greh->flags == 0 && tpi->proto == htons(ETH_P_WCCP)) {
tpi->proto = proto;
if ((*(u8 *)options & 0xF0) != 0x40)
hdr_len += 4;
}
tpi->hdr_len = hdr_len;
/* ERSPAN ver 1 and 2 protocol sets GRE key field
* to 0 and sets the configured key in the
* inner erspan header field
*/
if (greh->protocol == htons(ETH_P_ERSPAN) ||
greh->protocol == htons(ETH_P_ERSPAN2)) {
struct erspan_base_hdr *ershdr;
if (!pskb_may_pull(skb, nhs + hdr_len + sizeof(*ershdr)))
return -EINVAL;
ershdr = (struct erspan_base_hdr *)options;
tpi->key = cpu_to_be32(get_session_id(ershdr));
}
return hdr_len;
}