int map_intd(char *s, char ** v, int dv)
{
int i, n = dv;
if (s == NULL)
{
LOG_AND_RETURN(dv, "map_int: s=>NULL, v=%p, %s %s", v,
v ? v[0] : "NULL", v ? v[1] : "NULL");
}
s = strip(s);
if (!*s)
LOG_AND_RETURN(dv, "map_int: s is empty");
if (v == NULL)
{
if (s[0] != '+' && s[0] != '-' && (s[0] < '0' || s[0] > '9'))
LOG_AND_RETURN(dv, "map_int: s not a number: %s, v=%p, %s %s", s, v,
v ? v[0] : "NULL", v ? v[1] : "NULL");
return atoi(s);
}
for (i = 0; v[i]; i++)
if (!strncasecmp(s, v[i], strlen(v[i])))
n = i;
return n;
}
static void
list_keys_retract(OrmConn conn, int sockfd, const char *datastore)
{
#define LOG_AND_RETURN(errmsg)\
do{ods_log_error_and_printf(sockfd,module_str,errmsg);return;}while(0)
// List the keys with retract flags.
ods_printf(sockfd,
"Database set to: %s\n"
"Retract Keys:\n"
"Zone: "
"Key role: "
"Id: "
"\n"
,datastore
);
OrmTransaction transaction(conn);
if (!transaction.started())
LOG_AND_RETURN("transaction not started");
{ OrmResultRef rows;
::ods::keystate::EnforcerZone enfzone;
if (!OrmMessageEnum(conn,enfzone.descriptor(),rows))
LOG_AND_RETURN("zone enumeration failed");
for (bool next=OrmFirst(rows); next; next=OrmNext(rows)) {
if (!OrmGetMessage(rows, enfzone, /*zones + keys*/true))
LOG_AND_RETURN("retrieving zone from database failed");
for (int k=0; k<enfzone.keys_size(); ++k) {
const ::ods::keystate::KeyData &key = enfzone.keys(k);
// Don't suggest ZSKs can be retracted, don't show them
if (key.role() == ::ods::keystate::ZSK)
continue;
// Only show keys that have the retract flag set.
if (key.ds_at_parent()!=::ods::keystate::retract)
continue;
std::string keyrole = keyrole_Name(key.role());
ods_printf(sockfd,
"%-31s %-13s %-40s\n",
enfzone.name().c_str(),
keyrole.c_str(),
key.locator().c_str()
);
}
}
}
#undef LOG_AND_RETURN
}
int map_float(char *s, int mul)
{
float f;
int r;
if (s == NULL)
LOG_AND_RETURN(0, "map_float: s=>NULL, mul=%d", mul);
if (s[0] != '+' && s[0] != '-' && (s[0] < '0' || s[0] > '9'))
LOG_AND_RETURN(0, "map_float: s not a number: %s, mul=%d", s, mul);
f = atof(s);
r = (int) (f * mul);
// LOG("atof returned %.1f, mul = %d, result=%d",f,mul,r);
return r;
}
pthread_t get_socket_thread(int s_id)
{
sockets *ss = get_sockets(s_id);
if (!ss)
LOG_AND_RETURN(0, "get_socket_thread: socket is NULL for s_id %d", s_id);
return ss->tid;
}
int add_ca(SCA *c)
{
int i, new_ca;
del_ca(c);
for (i = 0; i < MAX_CA; i++)
if (!ca[i].enabled)
{
mutex_lock(&ca_mutex);
if (!ca[i].enabled)
break;
mutex_unlock(&ca_mutex);
}
if (i == MAX_CA)
LOG_AND_RETURN(0, "No free CA slots for %p", ca);
new_ca = i;
ca[new_ca].enabled = 1;
for (i = 0; i < sizeof(ca[0].action) / sizeof(ca_action); i++)
{
ca[new_ca].action[i] = c->action[i];
}
if (new_ca >= nca)
nca = new_ca + 1;
init_ca_device(c);
mutex_unlock(&ca_mutex);
return new_ca;
}
streams *
setup_stream (char *str, sockets * s)
{
char *arg[20], pol;
streams *sid;
int i;
transponder t;
init_hw ();
detect_dvb_parameters (str, &t);
LOG ("Setup stream %d parameters, sock_id %d, handle %d", s->sid,
s->id, s->sock);
if (!get_sid(s->sid)) // create the stream
{
int a_id = 0,
s_id = 0;
char pol;
s_id = streams_add ();
if(!(sid = get_sid(s_id)))
LOG_AND_RETURN ( NULL, "Could not add a new stream");
s->sid = s_id;
// s->close_sec = 200;
// s->timeout = (socket_action) stream_timeout;
LOG ("Setup stream done: sid: %d (e:%d) for sock %d handle %d", s_id,
st[s_id].enabled, s->id, s->sock);
}
if (!( sid = get_sid(s->sid)))
LOG_AND_RETURN (NULL, "Stream %d not enabled for sock_id %d handle %d",
s->sid, s->id, s->sock);
set_stream_parameters (s->sid, &t);
sid->do_play = 0;
if(sid->adapter >= 0 && !strncasecmp( s->buf, "SETUP", 5 )) // SETUP after PLAY
{
int ad = sid->adapter;
sid->adapter = -1;
close_adapter_for_stream(sid->sid, ad);
}
return sid;
}
char *readfile(char *fn, char *ctype, int *len)
{
char ffn[256];
char *mem;
struct stat sb;
int fd, i, nl = 0, sr;
*len = 0;
ctype[0] = 0;
if (strstr(fn, ".."))
return 0;
snprintf(ffn, sizeof(ffn), "%s/%s", opts.document_root, fn);
ffn[sizeof(ffn) - 1] = 0;
if ((fd = open(ffn, O_RDONLY)) < 0)
LOG_AND_RETURN(NULL, "Could not open file %s", ffn);
if ((fstat(fd, &sb) == -1) || !S_ISREG(sb.st_mode))
{
LOG("readfile: %s is not a file", ffn);
close(fd);
return NULL;
}
nl = sb.st_size;
mem = mmap(0, nl, PROT_READ, MAP_SHARED, fd, 0);
if (mem == MAP_FAILED)
LOG_AND_RETURN(NULL, "mmap failed for file %s", ffn);
close(fd);
LOG("opened %s fd %d at %x - %d bytes", ffn, fd, mem, nl);
*len = nl;
if (ctype)
{
if (endswith(fn, "png"))
strcpy(ctype, "Content-type: image/png\r\nConnection: close");
else if (endswith(fn, "jpg") || endswith(fn, "jpeg"))
strcpy(ctype, "Content-type: image/jpeg\r\nConnection: close");
else if (endswith(fn, "htm") || endswith(fn, "html"))
strcpy(ctype, "CACHE-CONTROL: no-cache\r\nContent-type: text/html");
else if (endswith(fn, "xml"))
strcpy(ctype, "CACHE-CONTROL: no-cache\r\nContent-type: text/xml");
}
return mem;
}
int dvb_del_filters(int fd, int pid)
{
if (fd < 0)
LOG_AND_RETURN(0, "DMX_STOP on an invalid handle %d, pid %d", fd, pid);
if (ioctl(fd, DMX_STOP, NULL) < 0)
LOG("DMX_STOP failed on PID %d FD %d: %s", pid, fd, strerror (errno))
else
LOG("clearing filter on PID %d FD %d", pid, fd);
close(fd);
return 0;
}
int sockets_add(int sock, struct sockaddr_in *sa, int sid, int type,
socket_action a, socket_action c, socket_action t)
{
int i;
char ra[50];
sockets *ss;
i = add_new_lock((void **) s, MAX_SOCKS, sizeof(sockets), &s_mutex);
if (i == -1)
LOG_AND_RETURN(-1, "sockets_add failed for socks %d", sock);
ss = s[i];
ss->enabled = 1;
ss->sock = sock;
ss->tid = get_tid();
memset(&ss->sa, 0, sizeof(ss->sa));
if (sa)
memcpy(&ss->sa, sa, sizeof(ss->sa));
ss->action = ss->close = ss->timeout = NULL;
if (a)
ss->action = a;
if (c)
ss->close = c;
if (t)
ss->timeout = t;
ss->sid = sid;
ss->type = type & ~TYPE_CONNECT;
ss->rtime = getTick();
ss->wtime = 0;
if (max_sock <= i)
max_sock = i + 1;
ss->buf = NULL;
ss->lbuf = 0;
ss->timeout_ms = 0;
ss->id = i;
ss->read = (read_action) sockets_read;
ss->lock = NULL;
if (ss->type == TYPE_UDP || ss->type == TYPE_RTCP)
ss->read = (read_action) sockets_recv;
else if (ss->type == TYPE_SERVER)
ss->read = (read_action) sockets_accept;
ss->events = POLLIN | POLLPRI;
if (type & TYPE_CONNECT)
ss->events |= POLLOUT;
LOG(
"sockets_add: handle %d (type %d) returning socket index %d [%s:%d] read: %p",
ss->sock, ss->type, i, get_socket_rhost(i, ra, sizeof(ra)),
ntohs(ss->sa.sin_port), ss->read);
mutex_unlock(&ss->mutex);
return i;
}
char *describe_streams (sockets *s, char *req, char *sbuf, int size)
{
char *str, *stream_id;
int i, sidf, do_play = 0, streams_enabled = 0;
streams *sid;
int do_all = 1;
if (s->sid == -1 && strchr(req, '?'))
setup_stream(req, s);
sidf = get_session_id(s->sid);
sid = get_sid(s->sid);
if(sid)
do_play = sid->do_play;
// else LOG_AND_RETURN(NULL, "No session associated with sock_id %d", s->sock_id);
snprintf(sbuf,size-1,"v=0\r\no=- %010d %010d IN IP4 %s\r\ns=SatIPServer:1 %d %d %d\r\nt=0 0\r\n", sidf, sidf, get_sock_host(s->sock), getS2Adapters(), getTAdapters(), getCAdapters() );
if(strchr(req, '?'))
do_all = 0;
if((stream_id = strstr(req, "stream=")))
{
do_all = 0;
sid = get_sid(map_int(stream_id + 7, NULL) - 1);
if(sid == NULL)
return NULL;
}
if(do_all)
{
for( i=0; i<MAX_STREAMS; i++)
if(st[i].enabled)
{
int slen=strlen(sbuf);
streams_enabled ++;
snprintf(sbuf + slen, size - slen - 1, "m=video %d RTP/AVP 33\r\nc=IN IP4 0.0.0.0\r\na=control:stream=%d\r\na=fmtp:33 %s\r\na=%s\r\n",
ntohs (st[i].sa.sin_port), i+1, describe_adapter(i, st[i].adapter), st[i].do_play?"sendonly":"inactive");
if( size - slen < 10)LOG_AND_RETURN(sbuf, "DESCRIBE BUFFER is full");
}
}else{
int slen = strlen(sbuf);
snprintf(sbuf + slen, size - slen - 1, "m=video 0 RTP/AVP 33\r\nc=IN IP4 0.0.0.0\r\na=control:stream=%d\r\na=fmtp:33 %s\r\nb=AS:5000\r\na=%s\r\n",
sid->sid + 1, describe_adapter(sid->sid, sid->adapter), do_play?"sendonly":"inactive");
}
return sbuf;
}
int
start_play (streams * sid, sockets * s)
{
int a_id;
if (sid->type == 0 && s->type == TYPE_HTTP)
{
sid->type = STREAM_HTTP;
sid->rsock = s->sock;
}
if(sid->type == 0)
{
// LOG("Assuming RTSP over TCP for stream %d, most likely transport was not specified", sid->sid);
// sid->type = STREAM_RTSP_TCP;
// sid->rsock = s->sock;
LOG_AND_RETURN(-454, "No Transport header was specified, for sid %d", sid->sid);
}
LOG ("Play for stream %d, type %d, rsock %d, adapter %d, sock_id %d handle %d", s->sid, sid->type, sid->rsock,
sid->adapter, s->id, s->sock);
if (sid->adapter == -1) // associate the adapter only at play (not at setup)
{
a_id =
get_free_adapter (sid->tp.freq, sid->tp.pol, sid->tp.sys,
sid->tp.fe);
LOG ("Got adapter %d on socket %d", a_id, s->id);
if (a_id < 0)
return -404;
sid->adapter = a_id;
set_adapter_for_stream (sid->sid, a_id);
}
if (set_adapter_parameters (sid->adapter, s->sid, &sid->tp) < 0)
return -404;
sid->do_play = 1;
sid->start_streaming = 0;
sid->tp.apids = sid->tp.dpids = sid->tp.pids = sid->tp.x_pmt = NULL;
return tune (sid->adapter, s->sid);
}
int dvb_tune(int aid, transponder * tp)
{
int bclear, bpol, iProp = 0;
adapter *ad = get_adapter(aid);
int fd_frontend = ad->fe;
int freq = tp->freq;
struct dtv_property p_cmd[20];
struct dtv_properties p =
{ .num = 0, .props = p_cmd };
struct dvb_frontend_event ev;
struct dtv_property p_clear[] =
{
{ .cmd = DTV_CLEAR }, };
struct dtv_properties cmdseq_clear =
{ .num = 1, .props = p_clear };
memset(p_cmd, 0, sizeof(p_cmd));
bclear = getTick();
if ((ioctl(fd_frontend, FE_SET_PROPERTY, &cmdseq_clear)) == -1)
{
LOG("FE_SET_PROPERTY DTV_CLEAR failed for fd %d: %s", fd_frontend,
strerror(errno));
// return -1;
}
switch (tp->sys)
{
case SYS_DVBS:
case SYS_DVBS2:
bpol = getTick();
freq = setup_switch(fd_frontend, tp);
if (freq < MIN_FRQ_DVBS || freq > MAX_FRQ_DVBS)
LOG_AND_RETURN(-404, "Frequency %d is not within range ", freq)
ADD_PROP(DTV_SYMBOL_RATE, tp->sr)
ADD_PROP(DTV_INNER_FEC, tp->fec)
ADD_PROP(DTV_PILOT, tp->plts)
ADD_PROP(DTV_ROLLOFF, tp->ro)
ADD_PROP(DTV_STREAM_ID, tp->plp)
LOG(
"tuning to %d(%d) pol: %s (%d) sr:%d fec:%s delsys:%s mod:%s rolloff:%s pilot:%s, ts clear=%d, ts pol=%d",
tp->freq, freq, get_pol(tp->pol), tp->pol, tp->sr,
fe_fec[tp->fec], fe_delsys[tp->sys], fe_modulation[tp->mtype],
fe_rolloff[tp->ro], fe_pilot[tp->plts], bclear, bpol)
break;
case SYS_DVBT:
case SYS_DVBT2:
if (tp->freq < MIN_FRQ_DVBT || tp->freq > MAX_FRQ_DVBT)
LOG_AND_RETURN(-404, "Frequency %d is not within range ", tp->freq)
freq = freq * 1000;
ADD_PROP(DTV_BANDWIDTH_HZ, tp->bw)
ADD_PROP(DTV_CODE_RATE_HP, tp->fec)
ADD_PROP(DTV_CODE_RATE_LP, tp->fec)
ADD_PROP(DTV_GUARD_INTERVAL, tp->gi)
ADD_PROP(DTV_TRANSMISSION_MODE, tp->tmode)
ADD_PROP(DTV_HIERARCHY, HIERARCHY_AUTO)
ADD_PROP(DTV_STREAM_ID, tp->plp & 0xFF)
LOG(
"tuning to %d delsys: %s bw:%d inversion:%s mod:%s fec:%s guard:%s transmission: %s, ts clear = %d",
freq, fe_delsys[tp->sys], tp->bw, fe_specinv[tp->inversion],
fe_modulation[tp->mtype], fe_fec[tp->fec], fe_gi[tp->gi],
fe_tmode[tp->tmode], bclear)
break;
case SYS_DVBC2:
case SYS_DVBC_ANNEX_A:
if (tp->freq < MIN_FRQ_DVBC || tp->freq > MAX_FRQ_DVBC)
LOG_AND_RETURN(-404, "Frequency %d is not within range ", tp->freq)
freq = freq * 1000;
ADD_PROP(DTV_SYMBOL_RATE, tp->sr)
ADD_PROP(DTV_STREAM_ID, ((tp->ds & 0xFF) << 8) | (tp->plp & 0xFF))
// valid for DD DVB-C2 devices
LOG("tuning to %d sr:%d specinv:%s delsys:%s mod:%s ts clear =%d", freq,
tp->sr, fe_specinv[tp->inversion], fe_delsys[tp->sys],
fe_modulation[tp->mtype], bclear)
break;
case SYS_ATSC:
case SYS_DVBC_ANNEX_B:
if (tp->freq < MIN_FRQ_DVBC || tp->freq > MAX_FRQ_DVBC)
LOG_AND_RETURN(-404, "Frequency %d is not within range ", tp->freq)
if (tp->mtype == 0)
tp->mtype = QAM_AUTO;
freq = freq * 1000;
LOG("tuning to %d delsys:%s mod:%s specinv:%s ts clear=%d", freq,
fe_delsys[tp->sys], fe_modulation[tp->mtype],
fe_specinv[tp->inversion], bclear)
break;
case SYS_ISDBT:
if (tp->freq < MIN_FRQ_DVBT || tp->freq > MAX_FRQ_DVBT)
LOG_AND_RETURN(-404, "Frequency %d is not within range ", tp->freq)
freq = freq * 1000;
ADD_PROP(DTV_ISDBT_PARTIAL_RECEPTION, 0)
ADD_PROP(DTV_BANDWIDTH_HZ, tp->bw)
// ADD_PROP(DTV_ISDBT_LAYERA_SEGMENT_COUNT, 1);
// ADD_PROP(DTV_ISDBT_LAYER_ENABLED, 1);
LOG("tuning to %d delsys: %s bw:%d inversion:%s , ts clear = %d", freq,
fe_delsys[tp->sys], tp->bw, fe_specinv[tp->inversion], bclear)
;
break;
default:
LOG("tuninng to unknown delsys: %s freq %s ts clear = %d", freq,
fe_delsys[tp->sys], bclear)
break;
}
ADD_PROP(DTV_FREQUENCY, freq)
ADD_PROP(DTV_INVERSION, tp->inversion)
ADD_PROP(DTV_MODULATION, tp->mtype);
ADD_PROP(DTV_DELIVERY_SYSTEM, tp->sys);
ADD_PROP(DTV_TUNE, 0)
p.num = iProp;
/* discard stale QPSK events */
while (1)
{
if (ioctl(fd_frontend, FE_GET_EVENT, &ev) == -1)
break;
}
if ((ioctl(fd_frontend, FE_SET_PROPERTY, &p)) == -1)
if (ioctl(fd_frontend, FE_SET_PROPERTY, &p) == -1)
{
perror("FE_SET_PROPERTY TUNE failed");
LOG("set property failed");
return -404;
}
return 0;
}
int dvb_set_pid(adapter *a, uint16_t i_pid)
{
char buf[100];
int fd;
int hw, ad;
hw = a->pa;
ad = a->fn;
if (i_pid > 8192)
LOG_AND_RETURN(-1, "pid %d > 8192 for /dev/dvb/adapter%d/demux%d",
i_pid, hw, ad);
sprintf(buf, "/dev/dvb/adapter%d/demux%d", hw, ad);
if ((fd = open(buf, O_RDWR | O_NONBLOCK)) < 0)
{
LOG("Could not open demux device /dev/dvb/adapter%d/demux%d: %s ", hw,
ad, strerror (errno));
return -1;
}
struct dmx_pes_filter_params s_filter_params;
memset(&s_filter_params, 0, sizeof(s_filter_params));
s_filter_params.pid = i_pid;
s_filter_params.input = DMX_IN_FRONTEND;
s_filter_params.output = DMX_OUT_TS_TAP;
s_filter_params.flags = DMX_IMMEDIATE_START;
s_filter_params.pes_type = DMX_PES_OTHER;
if (ioctl(fd, DMX_SET_PES_FILTER, &s_filter_params) < 0)
{
int pids[MAX_PIDS];
int ep;
ep = get_enabled_pids(a, (int *) pids, MAX_PIDS);
LOG("failed setting filter on %d (%s), enabled pids %d", i_pid,
strerror (errno), ep);
return -1;
}
LOG("setting filter on PID %d for fd %d", i_pid, fd);
return fd;
}
void
perform_keystate_export(int sockfd, engineconfig_type *config, const char *zone,
int bds)
{
#define LOG_AND_RETURN(errmsg) do { ods_log_error_and_printf(\
sockfd,module_str,errmsg); return; } while (0)
#define LOG_AND_RETURN_1(errmsg,param) do { ods_log_error_and_printf(\
sockfd,module_str,errmsg,param); return; } while (0)
GOOGLE_PROTOBUF_VERIFY_VERSION;
OrmConnRef conn;
if (!ods_orm_connect(sockfd, config, conn))
return; // error already reported.
{ OrmTransactionRW transaction(conn);
if (!transaction.started())
LOG_AND_RETURN("transaction not started");
std::string qzone;
if (!OrmQuoteStringValue(conn, std::string(zone), qzone))
LOG_AND_RETURN("quoting string value failed");
{ OrmResultRef rows;
::ods::keystate::EnforcerZone enfzone;
if (!OrmMessageEnumWhere(conn,enfzone.descriptor(),
rows,"name = %s",qzone.c_str()))
LOG_AND_RETURN("zone enumeration failed");
if (!OrmFirst(rows)) {
ods_printf(sockfd,"zone %s not found\n",zone);
return;
}
OrmContextRef context;
if (!OrmGetMessage(rows, enfzone, /*zones + keys*/true, context))
LOG_AND_RETURN("retrieving zone from database failed");
// we no longer need the query result, so release it.
rows.release();
// Retrieve the dnskey ttl from the policy associated with the zone.
::ods::kasp::Policy policy;
if (!load_kasp_policy(conn, enfzone.policy(), policy))
LOG_AND_RETURN_1("policy %s not found",enfzone.policy().c_str());
uint32_t dnskey_ttl = policy.keys().ttl();
bool bSubmitChanged = false;
bool bRetractChanged = false;
bool bKeytagChanged = false;
for (int k=0; k<enfzone.keys_size(); ++k) {
const ::ods::keystate::KeyData &key = enfzone.keys(k);
if (key.role()==::ods::keystate::ZSK)
continue;
if (key.ds_at_parent()!=::ods::keystate::submit
&& key.ds_at_parent()!=::ods::keystate::submitted
&& key.ds_at_parent()!=::ods::keystate::retract
&& key.ds_at_parent()!=::ods::keystate::retracted
)
continue;
std::string dnskey;
uint16_t keytag = dnskey_from_id(dnskey,key.locator().c_str(),
key.role(),
enfzone.name().c_str(),
key.algorithm(),bds,
dnskey_ttl);
if (keytag) {
ods_writen(sockfd, dnskey.c_str(), dnskey.size());
bSubmitChanged = key.ds_at_parent()==::ods::keystate::submit;
bRetractChanged = key.ds_at_parent()==::ods::keystate::retract;
bKeytagChanged = key.keytag()!=keytag;
if (bSubmitChanged) {
::ods::keystate::KeyData *kd = enfzone.mutable_keys(k);
kd->set_ds_at_parent(::ods::keystate::submitted);
}
if (bRetractChanged) {
::ods::keystate::KeyData *kd = enfzone.mutable_keys(k);
kd->set_ds_at_parent(::ods::keystate::retracted);
}
if (bKeytagChanged) {
::ods::keystate::KeyData *kd = enfzone.mutable_keys(k);
kd->set_keytag(keytag);
}
} else
LOG_AND_RETURN_1("unable to find key with id %s",
key.locator().c_str());
}
if (bSubmitChanged || bRetractChanged || bKeytagChanged) {
// Update the zone recursively in the database as keystates
// have been changed because of the export
if (!OrmMessageUpdate(context))
LOG_AND_RETURN("updating zone in the database failed");
if (!transaction.commit())
LOG_AND_RETURN("committing zone to the database failed");
}
}
}
}
static void
retract_keys(OrmConn conn,
int sockfd,
const char *zone,
const char *id,
const char *datastore,
const char *ds_retract_command)
{
#define LOG_AND_RETURN(errmsg)\
do{ods_log_error_and_printf(sockfd,module_str,errmsg);return;}while(0)
#define LOG_AND_RETURN_1(errmsg,p)\
do{ods_log_error_and_printf(sockfd,module_str,errmsg,p);return;}while(0)
OrmTransactionRW transaction(conn);
if (!transaction.started())
LOG_AND_RETURN("transaction not started");
{ OrmResultRef rows;
::ods::keystate::EnforcerZone enfzone;
if (zone) {
std::string qzone;
if (!OrmQuoteStringValue(conn, std::string(zone), qzone))
LOG_AND_RETURN("quoting string value failed");
if (!OrmMessageEnumWhere(conn,enfzone.descriptor(),
rows,"name = %s",qzone.c_str()))
LOG_AND_RETURN("zone enumeration failed");
} else {
if (!OrmMessageEnum(conn,enfzone.descriptor(),rows))
LOG_AND_RETURN("zone enumeration failed");
}
bool bZonesModified = false;
if (!OrmFirst(rows)) {
if (zone)
LOG_AND_RETURN_1("zone %s not found",zone);
} else {
for (bool next=true; next; next=OrmNext(rows)) {
OrmContextRef context;
if (!OrmGetMessage(rows, enfzone, /*zones + keys*/true, context))
LOG_AND_RETURN("retrieving zone from database failed");
// Try to change the state of a specific 'retract' key to 'retracted'.
bool bKeyModified = false;
for (int k=0; k<enfzone.keys_size(); ++k) {
const ::ods::keystate::KeyData &key = enfzone.keys(k);
// Don't retract ZSKs from the parent.
if (key.role()==::ods::keystate::ZSK)
continue;
// Only retract KSKs that have the retract flag set.
if (key.ds_at_parent()!=::ods::keystate::retract)
continue;
if (id) {
// --id <id>
// Force retract key to the parent for specific key id.
if (key.locator()==id) {
// retract key with this id from the parent
if (retract_dnskey_by_id(sockfd,ds_retract_command,
key.locator().c_str(),
key.role(),
enfzone.name().c_str(),
key.algorithm()))
{
::ods::keystate::KeyData *kd =
enfzone.mutable_keys(k);
kd->set_ds_at_parent(::ods::keystate::retracted);
bKeyModified = true;
}
}
} else {
if (zone) {
// --zone <zone>
// Force retract key from the parent for specific zone.
if (enfzone.name()==zone) {
// retract key for this zone from the parent
if (retract_dnskey_by_id(sockfd,ds_retract_command,
key.locator().c_str(),
key.role(),
enfzone.name().c_str(),
key.algorithm()))
{
::ods::keystate::KeyData *kd =
enfzone.mutable_keys(k);
kd->set_ds_at_parent(::ods::keystate::retracted);
bKeyModified = true;
}
}
} else {
// --auto
// Retract all keys from the parent that have
// the retract flag set.
if (retract_dnskey_by_id(sockfd,ds_retract_command,
key.locator().c_str(),
key.role(),
enfzone.name().c_str(),
key.algorithm()))
{
::ods::keystate::KeyData *kd =
enfzone.mutable_keys(k);
kd->set_ds_at_parent(::ods::keystate::retracted);
bKeyModified = true;
}
}
}
}
if (bKeyModified) {
if (!OrmMessageUpdate(context))
LOG_AND_RETURN_1("failed to update zone %s in the database", enfzone.name().c_str());
bZonesModified = true;
}
}
// we no longer need the query result, so release it.
rows.release();
}
// Report back the status of the operation.
if (bZonesModified) {
// Commit updated records to the database.
if (!transaction.commit())
LOG_AND_RETURN_1("unable to commit updated zone %s to the database",zone);
ods_log_debug("[%s] key states have been updated",module_str);
ods_printf(sockfd,"update of key states completed.\n");
} else {
ods_log_debug("[%s] key states are unchanged",module_str);
if (id)
ods_printf(sockfd,
"No key state changes for id \"%s\"\n",
id);
else
if (zone)
ods_printf(sockfd,
"No key state changes for zone \"%s\"\n",
zone);
else
ods_printf(sockfd,"key states are unchanged\n");
}
}
#undef LOG_AND_RETURN
#undef LOG_AND_RETURN_1
}
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);
}
}
