/**
* Mark clients as having sent status as specified by PRSTATUS
*/
void set_proxy_status(struct finfo_t *finfo, const unsigned char *data,
int hostidx, int nak_count)
{
struct prstatus_h *prstatus;
uint32_t *addrlist;
int clientcnt, clientidx, dupmsg, i;
prstatus = (struct prstatus_h *)data;
addrlist = (uint32_t *)(data + sizeof(struct prstatus_h));
clientcnt = ntohs(prstatus->destcount);
for (i = 0; i < clientcnt; i++) {
clientidx = find_client(addrlist[i]);
if (clientidx == -1) {
log1(0, 0, "Client %s via proxy %s not found",
inet_ntoa(to_addr(addrlist[i])), destlist[hostidx].name);
} else if (destlist[clientidx].proxyidx != hostidx) {
log1(0, 0, "Client %s found via proxy %s, expected proxy %s",
destlist[clientidx].name,
destlist[destlist[clientidx].proxyidx].name,
destlist[hostidx].name);
} else if (!client_error(clientidx)) {
dupmsg = (destlist[clientidx].status == DEST_ACTIVE);
destlist[clientidx].status = DEST_ACTIVE;
log(0, 0, " For client%s %s", dupmsg ? "+" : "",
destlist[clientidx].name);
if (!dupmsg) {
finfo->deststate[clientidx].naks += nak_count;
}
}
}
}
bool Sound::play(void)
{
bool success=false;
int rc;
if (!tune || ! (tune->size() > 0)) {
log2 ("no tune file set, or a play is in progress (tune, playing)", tune, playing);
}
else {
// Call external tool with the sound file
playing = true;
string sound_cmdline;
sound_cmdline = "/usr/bin/aplay ";
sound_cmdline += tune->c_str();
sound_cmdline += " &";
log1 ("Playing sound cmdline:", sound_cmdline);
// protect against eventual race condition
tune_tmp=tune;
tune = NULL;
delete (tune_tmp);
rc = system (sound_cmdline.c_str());
log1 ("Sound played (return code)", rc);
success = (rc == 0 ? true : false);
playing = false;
}
return success;
}
/**
* Do basic checking on a received packet, like checking the version
* and making sure the size matches the size in the header.
* Returns 1 on success, 0 on fail.
*/
int validate_packet(const unsigned char *packet, int len,
const struct finfo_t *finfo)
{
struct uftp_h *header;
header = (struct uftp_h *)packet;
if ((header->uftp_id != UFTP_VER_NUM) &&
(header->uftp_id != UFTP_3_0_VER)) {
log1(0, 0, "Invalid version %02X", header->uftp_id);
return 0;
}
if (len - sizeof(struct uftp_h) != ntohs(header->blsize)) {
log1(0, 0, "Invalid packet size %d, expected %d",
len - sizeof(struct uftp_h), ntohs(header->blsize));
return 0;
}
if (ntohl(header->group_id) != finfo->group_id) {
log1(0, 0, "Invalid group ID %08X, expected %08X",
ntohl(header->group_id), finfo->group_id);
return 0;
}
if ((header->func == ENCRYPTED) && (keytype == KEY_NONE)) {
log1(0, 0, "Received encrypted packet with encryption disabled");
return 0;
}
return 1;
}
w_Targs* cpiPython::SQL (int id, w_Targs* args) // (char *query)
{
char *query;
string q;
long limit;
if (!lib_begin || !lib_pack || !lib_unpack || !lib_packprint || !mQuery) return NULL;
if (!lib_unpack(args, "sl", &query, &limit)) return NULL;
if (!query) return NULL;
if (limit < 1) limit = 100;
log4("PY: SQL query: %s\n", query);
q = string() + query;
mQuery->OStream() << q;
if (mQuery->Query() < 0) { mQuery->Clear(); return lib_pack("lllp", (long)0, (long)0, (long)0, (void*)NULL); } // error
int rows = mQuery->StoreResult();
if (limit < rows) rows = limit;
if (rows < 1) { mQuery->Clear(); return lib_pack("lllp", (long)1, (long)0, (long)0, (void*)NULL); }
int cols = mQuery->Cols();
char * nil = (char*)"NULL";
char ** res = (char **) calloc (cols*rows, sizeof(char*));
if (!res) { log1("PY: SQL malloc failed\n"); mQuery->Clear(); return lib_pack("lllp", (long)0, (long)0, (long)0, (void*)NULL); }
for (int r = 0 ; r < rows; r++)
{
mQuery->DataSeek(r);
MYSQL_ROW row;
row = mQuery->Row();
if (!row)
{ log1("PY: SQL failed to fetch row: %d\n", r); mQuery->Clear(); free(res); return lib_pack("lllp", (long)0, (long)0, (long)0, (void*)NULL); }
for (int i = 0; i < cols; i++)
res[(r*cols)+i] = strdup( (row[i]) ? row[i] : nil );
}
mQuery->Clear();
return lib_pack("lllp", (long)1, (long)rows, (long)cols, (void*)res);
}
/**
* Process an KEY_REQ message
*/
void handle_key_req(const union sockaddr_u *src,
const unsigned char *packet, unsigned packetlen)
{
const struct key_req_h *keyreq;
struct timeval current_timestamp;
char destname[INET6_ADDRSTRLEN];
int rval;
keyreq = (const struct key_req_h *)(packet + sizeof(struct uftp_h));
if ((rval = getnameinfo((const struct sockaddr *)src, family_len(*src),
destname, sizeof(destname), NULL, 0, NI_NUMERICHOST)) != 0) {
log1(0, 0, 0, "getnameinfo failed: %s", gai_strerror(rval));
}
if ((packetlen < sizeof(struct uftp_h) + (keyreq->hlen * 4U)) ||
((keyreq->hlen * 4U) < sizeof(struct key_req_h))) {
log1(0,0,0,"Rejecting KEY_REQ from %s: invalid message size", destname);
return;
}
log2(0, 0, 0, "Received KEY_REQ from %s", destname);
gettimeofday(¤t_timestamp, NULL);
if (diff_sec(current_timestamp, last_key_req) > KEY_REQ_LIMIT) {
send_proxy_key();
}
}
static void SetCachedVariant( DBVARIANT* s /* new */, DBVARIANT* d /* cached */ )
{
char* szSave = ( d->type == DBVT_UTF8 || d->type == DBVT_ASCIIZ ) ? d->pszVal : NULL;
memcpy( d, s, sizeof( DBVARIANT ));
if (( s->type == DBVT_UTF8 || s->type == DBVT_ASCIIZ ) && s->pszVal != NULL ) {
if ( szSave != NULL )
d->pszVal = (char*)HeapReAlloc(hCacheHeap,0,szSave,strlen(s->pszVal)+1);
else
d->pszVal = (char*)HeapAlloc(hCacheHeap,0,strlen(s->pszVal)+1);
strcpy(d->pszVal,s->pszVal);
}
else if ( szSave != NULL )
HeapFree(hCacheHeap,0,szSave);
#ifdef DBLOGGING
switch( d->type ) {
case DBVT_BYTE: log1( "set cached byte: %d", d->bVal ); break;
case DBVT_WORD: log1( "set cached word: %d", d->wVal ); break;
case DBVT_DWORD: log1( "set cached dword: %d", d->dVal ); break;
case DBVT_UTF8:
case DBVT_ASCIIZ: log1( "set cached string: '%s'", d->pszVal ); break;
default: log1( "set cached crap: %d", d->type ); break;
}
#endif
}
static double truncation(double u, double tausq)
/* bound integration error due to truncation at u */
{
double sum1, sum2, prod1, prod2, prod3, lj, ncj,
x, y, err1, err2;
int j, nj, s;
counter();
sum1 = 0.0; prod2 = 0.0; prod3 = 0.0; s = 0;
sum2 = (sigsq + tausq) * square(u); prod1 = 2.0 * sum2;
u = 2.0 * u;
for (j=0; j<r; j++ )
{
lj = lb[j]; ncj = nc[j]; nj = n[j];
x = square(u * lj);
sum1 = sum1 + ncj * x / (1.0 + x);
if (x > 1.0)
{
prod2 = prod2 + nj * log(x);
prod3 = prod3 + nj * log1(x, TRUE );
s = s + nj;
}
else prod1 = prod1 + nj * log1(x, TRUE );
}
sum1 = 0.5 * sum1;
prod2 = prod1 + prod2; prod3 = prod1 + prod3;
x = exp1(-sum1 - 0.25 * prod2) / pi;
y = exp1(-sum1 - 0.25 * prod3) / pi;
err1 = ( s == 0 ) ? 1.0 : x * 2.0 / s;
err2 = ( prod3 > 1.0 ) ? 2.5 * y : 1.0;
if (err2 < err1) err1 = err2;
x = 0.5 * sum2;
err2 = ( x <= y ) ? 1.0 : y / x;
return ( err1 < err2 ) ? err1 : err2;
}
/* Send a packet to a specific mac address and ip address by creating our own ip packet */
static void send_packet_to_client(struct dhcp_packet *dhcp_pkt, int force_broadcast)
{
const uint8_t *chaddr;
uint32_t ciaddr;
// Was:
//if (force_broadcast) { /* broadcast */ }
//else if (dhcp_pkt->ciaddr) { /* unicast to dhcp_pkt->ciaddr */ }
//else if (dhcp_pkt->flags & htons(BROADCAST_FLAG)) { /* broadcast */ }
//else { /* unicast to dhcp_pkt->yiaddr */ }
// But this is wrong: yiaddr is _our_ idea what client's IP is
// (for example, from lease file). Client may not know that,
// and may not have UDP socket listening on that IP!
// We should never unicast to dhcp_pkt->yiaddr!
// dhcp_pkt->ciaddr, OTOH, comes from client's request packet,
// and can be used.
if (force_broadcast
|| (dhcp_pkt->flags & htons(BROADCAST_FLAG))
|| dhcp_pkt->ciaddr == 0
) {
log1("Broadcasting packet to client");
ciaddr = INADDR_BROADCAST;
chaddr = MAC_BCAST_ADDR;
} else {
log1("Unicasting packet to client ciaddr");
ciaddr = dhcp_pkt->ciaddr;
chaddr = dhcp_pkt->chaddr;
}
udhcp_send_raw_packet(dhcp_pkt,
/*src*/ server_config.server_nip, SERVER_PORT,
/*dst*/ ciaddr, CLIENT_PORT, chaddr,
server_config.ifindex);
}
int FAST_FUNC udhcp_read_interface(const char *interface, int *ifindex, uint32_t *nip, uint8_t *mac, uint16_t *mtu)
{
/* char buffer instead of bona-fide struct avoids aliasing warning */
char ifr_buf[sizeof(struct ifreq)];
struct ifreq *const ifr = (void *)ifr_buf;
int fd;
struct sockaddr_in *our_ip;
memset(ifr, 0, sizeof(*ifr));
fd = xsocket(AF_INET, SOCK_RAW, IPPROTO_RAW);
ifr->ifr_addr.sa_family = AF_INET;
strncpy_IFNAMSIZ(ifr->ifr_name, interface);
if (nip) {
if (ioctl_or_perror(fd, SIOCGIFADDR, ifr,
"is interface %s up and configured?", interface)
) {
close(fd);
return -1;
}
our_ip = (struct sockaddr_in *) &ifr->ifr_addr;
*nip = our_ip->sin_addr.s_addr;
log1("IP %s", inet_ntoa(our_ip->sin_addr));
}
if (ifindex) {
if (ioctl_or_warn(fd, SIOCGIFINDEX, ifr) != 0) {
close(fd);
return -1;
}
log1("Adapter index %d", ifr->ifr_ifindex);
*ifindex = ifr->ifr_ifindex;
}
if (mac) {
if (ioctl_or_warn(fd, SIOCGIFHWADDR, ifr) != 0) {
close(fd);
return -1;
}
memcpy(mac, ifr->ifr_hwaddr.sa_data, 6);
log1("MAC %02x:%02x:%02x:%02x:%02x:%02x",
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
}
if (mtu) {
if (ioctl_or_warn(fd, SIOCGIFMTU, ifr) != 0) {
close(fd);
return -1;
}
log1("Adapter mtu %d", ifr->ifr_mtu);
*mtu = ifr->ifr_mtu;
}
close(fd);
return 0;
}
/**
* Print the final statistics for the given file
*/
void print_status(const struct finfo_t *finfo, struct timeval start_time)
{
struct timeval done_time;
double elapsed_time;
int i;
if (sync_mode) {
print_sync_status(finfo, start_time);
return;
}
if (finfo->file_id == 0) {
log0(0, 0, "Group complete");
return;
}
log0(0, 0, "Transfer status:");
for (done_time = start_time, i = 0; i < destcount; i++) {
if (destlist[i].clientcnt >= 0) {
continue;
}
clog0(0, 0, "Host: %-15s Status: ", destlist[i].name);
switch (destlist[i].status) {
case DEST_MUTE:
slog0("Mute");
break;
case DEST_LOST:
slog0("Lost connection");
break;
case DEST_ABORT:
slog0("Aborted");
break;
case DEST_DONE:
if (destlist[i].comp_status == COMP_STAT_REJECTED) {
slog0("Rejected");
break;
}
if (diff_usec(finfo->deststate[i].time, done_time) > 0) {
done_time = finfo->deststate[i].time;
}
elapsed_time = (double)diff_usec(finfo->deststate[i].time,
start_time) / 1000000;
slog0("Completed time: %7.3f seconds NAKs: %d",
elapsed_time, finfo->deststate[i].naks);
break;
default:
slog0("Unknown code: %d", destlist[i].status);
break;
}
}
elapsed_time = (double)diff_usec(done_time, start_time) / 1000000;
log1(0, 0, "Total elapsed time: %.3f seconds", elapsed_time);
log1(0, 0, "Overall throughput: %.2f KB/s",
(elapsed_time != 0) ? (finfo->size / elapsed_time / 1024) : 0);
}
void cls(uint8_t Port)
{
if(Port==1)
{
log1(ESC_ERASE_DISPLAY);
log1(ESC_CURSOR_POS(0,0));
}
else
{
log0(ESC_ERASE_DISPLAY);
log0(ESC_CURSOR_POS(0,0));
}
}
/* Read a packet from socket fd, return -1 on read error, -2 on packet error */
int FAST_FUNC udhcp_recv_kernel_packet(struct dhcp_packet *packet, int fd)
{
int bytes;
unsigned char *vendor;
memset(packet, 0, sizeof(*packet));
bytes = safe_read(fd, packet, sizeof(*packet));
if (bytes < 0) {
log1("Packet read error, ignoring");
return bytes; /* returns -1 */
}
if (packet->cookie != htonl(DHCP_MAGIC)) {
bb_info_msg("Packet with bad magic, ignoring");
return -2;
}
log1("Received a packet");
udhcp_dump_packet(packet);
if (packet->op == BOOTREQUEST) {
vendor = udhcp_get_option(packet, DHCP_VENDOR);
if (vendor) {
#if 0
static const char broken_vendors[][8] = {
"MSFT 98",
""
};
int i;
for (i = 0; broken_vendors[i][0]; i++) {
if (vendor[OPT_LEN - OPT_DATA] == (uint8_t)strlen(broken_vendors[i])
&& strncmp((char*)vendor, broken_vendors[i], vendor[OPT_LEN - OPT_DATA]) == 0
) {
log1("Broken client (%s), forcing broadcast replies",
broken_vendors[i]);
packet->flags |= htons(BROADCAST_FLAG);
}
}
#else
if (vendor[OPT_LEN - OPT_DATA] == (uint8_t)(sizeof("MSFT 98")-1)
&& memcmp(vendor, "MSFT 98", sizeof("MSFT 98")-1) == 0
) {
log1("Broken client (%s), forcing broadcast replies", "MSFT 98");
packet->flags |= htons(BROADCAST_FLAG);
}
#endif
}
}
return bytes;
}
/**
* Process an ABORT message
*/
void handle_abort(const unsigned char *message, int meslen, int idx,
struct finfo_t *finfo, const struct in_addr *hostaddr)
{
struct abort_h *abort;
int i;
abort = (struct abort_h *)message;
if (meslen != sizeof(struct abort_h)) {
log1(0, 0, "Rejecting ABORT from %s: invalid message size",
(idx == -1) ? inet_ntoa(*hostaddr) : destlist[idx].name);
return;
}
if (idx == -1) {
log1(0, 0, "Transfer aborted by %s: %s",
inet_ntoa(*hostaddr), abort->message);
return;
}
if (abort->host != 0) {
idx = find_client(abort->host);
}
if (idx == -1) {
log1(0, 0, "Transfer aborted by %s: %s",
inet_ntoa(*hostaddr), abort->message);
} else {
destlist[idx].status = DEST_ABORT;
log1(0, 0, "Transfer aborted by %s: %s",
destlist[idx].name, abort->message);
}
if (quit_on_error) {
log0(0, 0, "Aboring all clients");
send_abort(finfo, "A client aborted, aborting all",
&receive_dest, NULL, 0);
// If encryption enabled, send ABORT both encrypted and unencrypted
// since we can't be sure what phase we're currently in.
if (keytype != KEY_NONE) {
send_abort(finfo, "A client aborted, aborting all",
&receive_dest, NULL, 1);
}
for (i = 0; i < destcount; i++) {
if ((destlist[i].status == DEST_ACTIVE) ||
(destlist[i].status == DEST_REGISTERED) ||
(destlist[i].status == DEST_STATUS)) {
destlist[i].status = DEST_ABORT;
}
}
}
}
static void integrate(int nterm, double interv, double tausq, BOOL mainx)
/* carry out integration with nterm terms, at stepsize
interv. if (! mainx) multiply integrand by
1.0-exp(-0.5*tausq*u^2) */
{
double inpi, u, sum1, sum2, sum3, x, y, z;
int k, j, nj;
inpi = interv / pi;
for ( k = nterm; k>=0; k--)
{
u = (k + 0.5) * interv;
sum1 = - 2.0 * u * c; sum2 = fabs(sum1);
sum3 = - 0.5 * sigsq * square(u);
for ( j = r-1; j>=0; j--)
{
nj = n[j]; x = 2.0 * lb[j] * u; y = square(x);
sum3 = sum3 - 0.25 * nj * log1(y, TRUE );
y = nc[j] * x / (1.0 + y);
z = nj * atan(x) + y;
sum1 = sum1 + z; sum2 = sum2 + fabs(z);
sum3 = sum3 - 0.5 * x * y;
}
x = inpi * exp1(sum3) / u;
if ( ! mainx )
x = x * (1.0 - exp1(-0.5 * tausq * square(u)));
sum1 = sin(0.5 * sum1) * x; sum2 = 0.5 * sum2 * x;
intl = intl + sum1; ersm = ersm + sum2;
}
}
bool cpiPython::CallAll(int func, w_Targs* args) // the default handler: returns true unless the calback returns 0
{
if (!online) return true;
w_Targs* result;
bool ret = true;
long l;
if (func != W_OnTimer) log2("PY: CallAll %s: parameters %s\n", lib_hookname(func), lib_packprint(args)) // no ';' since this would break 'else'
else log4("PY: CallAll %s\n", lib_hookname(func));
if(Size())
{
tvPythonInterpreter::iterator it;
for(it = mPython.begin(); it != mPython.end(); ++it)
{
result = (*it)->CallFunction(func, args);
if(!result)
{
// callback doesn't exist or a failure
if (func != W_OnTimer) log4("PY: CallAll %s: returned NULL\n", lib_hookname(func));
continue;
}
if(lib_unpack(result, "l", &l)) // default return value is 1L meaning: further processing,
{
if (func != W_OnTimer) log3("PY: CallAll %s: returned l:%ld\n", lib_hookname(func), l);
if (!l) ret = false; // 0L means no more processing outside this plugin
}
else // something unknown was returned... we will let the hub call other plugins
{
log1("PY: CallAll %s: unexpected return value %s\n", lib_hookname(func), lib_packprint(result));
}
free(result);
}
}
free(args); // WARNING: args is freed, do not try to access it after calling CallAll!
return ret;
}
int _tmain(int argc, _TCHAR* argv[])
{
::CoInitialize(0);
log1();
::CoUninitialize();
return 0;
}
bool cpiPython::OnParsedMsgChat(cConnDC *conn, cMessageDC *msg)
{
if (!online) return true;
if((conn != NULL) && (conn->mpUser != NULL) && (msg != NULL))
{
int func = W_OnParsedMsgChat;
w_Targs* args = lib_pack( "ss", conn->mpUser->mNick.c_str(), msg->ChunkString(eCH_CH_MSG).c_str());
log2("PY: Call %s: parameters %s\n", lib_hookname(func), lib_packprint(args));
bool ret = true;
w_Targs *result;
long l;
char *nick = NULL;
char *message = NULL;
if(Size())
{
tvPythonInterpreter::iterator it;
for(it = mPython.begin(); it != mPython.end(); ++it)
{
result = (*it)->CallFunction(func, args);
if(!result)
{
log3("PY: Call %s: returned NULL\n", lib_hookname(func));
continue;
}
if(lib_unpack(result, "l", &l)) // default return value is 1L meaning: further processing,
{
log3("PY: Call %s: returned l:%ld\n", lib_hookname(func), l);
if (!l) ret = false; // 0L means no more processing outside this plugin
}
else if (lib_unpack(result, "ss", &nick, &message)) // script wants to change nick or contents of the message
{
// normally you would use SendDataToAll and return 0 from your script
// but this kind of message modification allows you to process it not by just one but as many scripts as you want
log2("PY: modifying message - Call %s: returned %s\n", lib_hookname(func), lib_packprint(result));
if (nick)
{
string &nick0 = msg->ChunkString(eCH_CH_NICK);
nick0 = nick;
msg->ApplyChunk(eCH_CH_NICK);
}
if (message)
{
string &message0 = msg->ChunkString(eCH_CH_MSG);
message0 = message;
msg->ApplyChunk(eCH_CH_MSG);
}
ret = true; // we've changed the message so we want the hub to process it and send it
}
else // something unknown was returned... we will let the hub call other plugins
log1("PY: Call %s: unexpected return value: %s\n", lib_hookname(func), lib_packprint(result));
free(result);
}
}
free(args);
return ret;
}
return true;
}
/* @Core */
Mat PDCounter::detect(Mat& input) {
string log1("Begin detecting...\n");
Mat output = input.clone();
for (vector<PDDetector>::iterator it = Detectors.begin(); it != Detectors.end(); it++) {
(*it).detect(output, Trackers);// NO parallel
}
string log2("All areas are detected...\n");
string lost = i_to_s(Trackers.tracking(output)); // NO parallel
string log3("Tracking completed...\nThe trackers lost " + lost + " pedestrians in this frame.\n");
if (showPedestrian) {
drawFounds(output, Trackers.getCurrRects(), PEDESTRIAN_COLOR);
}
if (showArea) {
for (vector<PDDetector>::iterator it = Detectors.begin(); it != Detectors.end(); it++) {
drawArea(output, (*it).getArea(), AREA_COLOR);
}
}
if (showTrajectory) {
for (int i = 0; i < Trackers.getSize(); i++) {
drawTrajectory(output, Trackers[i].getTrajectory(), Trajectory_COLOR);
}
}
string log4("Drawing completed");
lastLog = log1 + log2 + log3 + log4;
return output;
}
static int dispatch_request(const command* table1, const command* table2,
int log)
{
const command* cmd;
cmd = find_command(table1);
if (!cmd && table2) cmd = find_command(table2);
if (!cmd) {
if (log) log2(request, req_param ? req_param : "(no parameter)");
return respond(502, 1, "Command not supported.");
}
if (req_param) {
if (log) log2(cmd->name, cmd->hideparam ? "XXXXXXXX" : req_param);
if (cmd->fn1)
return cmd->fn1();
return respond(501, 1, "Command requires no parameter");
}
else {
if (log) log1(cmd->name);
if (cmd->fn0)
return cmd->fn0();
return respond(504, 1, "Command requires a parameter");
}
}
static __inline void LoadSection(const int i,DWORD ofs)
{
cacheSectionInfo[i].ofsBase=ofs-ofs%CACHESECTIONSIZE;
log1("readsect %08x",ofs);
SetFilePointer(hDbFile,cacheSectionInfo[i].ofsBase,NULL,FILE_BEGIN);
ReadFile(hDbFile,pDbCache+i*CACHESECTIONSIZE,CACHESECTIONSIZE,&ofs,NULL);
}
/* Send a packet to gateway_nip using the kernel ip stack */
static void send_packet_to_relay(struct dhcp_packet *dhcp_pkt)
{
log1("Forwarding packet to relay");
udhcp_send_kernel_packet(dhcp_pkt,
server_config.server_nip, SERVER_PORT,
dhcp_pkt->gateway_nip, SERVER_PORT);
}
tReadWriteMutex::tReadWriteMutex(const int _max):semaphore(_max), write_user_login("")
{
max=_max;
QString s="Blocker ";
tLog log1(s);
log=log1;
}
int FAST_FUNC udhcp_read_interface(const char *interface, int *ifindex, uint32_t *nip, uint8_t *mac)
{
int fd;
struct ifreq ifr;
struct sockaddr_in *our_ip;
memset(&ifr, 0, sizeof(ifr));
fd = xsocket(AF_INET, SOCK_RAW, IPPROTO_RAW);
ifr.ifr_addr.sa_family = AF_INET;
strncpy(ifr.ifr_name, interface, sizeof(ifr.ifr_name));
if (nip) {
if (ioctl_or_perror(fd, SIOCGIFADDR, &ifr,
"is interface %s up and configured?", interface)
) {
close(fd);
return -1;
}
our_ip = (struct sockaddr_in *) &ifr.ifr_addr;
*nip = our_ip->sin_addr.s_addr;
log1("IP %s", inet_ntoa(our_ip->sin_addr));
}
if (ifindex) {
if (ioctl_or_warn(fd, SIOCGIFINDEX, &ifr) != 0) {
close(fd);
return -1;
}
log1("Adapter index %d", ifr.ifr_ifindex);
*ifindex = ifr.ifr_ifindex;
}
if (mac) {
if (ioctl_or_warn(fd, SIOCGIFHWADDR, &ifr) != 0) {
close(fd);
return -1;
}
memcpy(mac, ifr.ifr_hwaddr.sa_data, 6);
log1("MAC %02x:%02x:%02x:%02x:%02x:%02x",
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
}
close(fd);
return 0;
}
/* NOINLINE: limit stack usage in caller */
static NOINLINE void send_NAK(struct dhcp_packet *oldpacket)
{
struct dhcp_packet packet;
init_packet(&packet, oldpacket, DHCPNAK);
log1("Sending NAK");
send_packet(&packet, /*force_bcast:*/ 1);
}
void die_controls() {
if (control_last.s) {
log3("alert: cannot start: unable to read controls (", control_last.s, ")\n");
}
else {
log1("alert: cannot start: unable to read controls\n");
}
_exit(111);
}
/**
* Save the state of a failed transfer so it can restarted later.
*/
void write_restart_file(int listidx)
{
struct file_t *fileinfo;
struct client_restart_t restart;
char restart_name[MAXPATHNAME];
int fd;
// Don't bother if we're not using a temp directory.
if (!strcmp(tempdir, "")) {
return;
}
log1(group_list[listidx].group_id, 0, "Writing restart file");
memset(&restart, 0, sizeof(restart));
fileinfo = &group_list[listidx].fileinfo;
if (group_list[listidx].phase != PHASE_MIDGROUP) {
restart.blocks = fileinfo->blocks;
restart.sections = fileinfo->sections;
restart.size = fileinfo->size;
strcpy(restart.name, fileinfo->name);
}
snprintf(restart_name, sizeof(restart_name), "%s%c_group_%08X_restart",
tempdir, PATH_SEP, group_list[listidx].group_id);
if ((fd = open(restart_name, OPENWRITE | O_CREAT | O_TRUNC, 0644)) == -1) {
syserror(group_list[listidx].group_id, 0,
"Failed to create restart file");
return;
}
if (file_write(fd, &restart, sizeof(restart)) == -1) {
log0(group_list[listidx].group_id, 0,
"Failed to write header for restart file");
goto errexit;
}
if (fileinfo->blocks && fileinfo->naklist) {
if (file_write(fd, fileinfo->naklist, fileinfo->blocks) == -1) {
log0(group_list[listidx].group_id, 0,
"Failed to write NAK list for restart file");
goto errexit;
}
}
if (fileinfo->sections && fileinfo->section_done) {
if (file_write(fd, fileinfo->section_done, fileinfo->sections) == -1) {
log0(group_list[listidx].group_id, 0,
"Failed to write section_done list for restart file");
goto errexit;
}
}
close(fd);
return;
errexit:
close(fd);
unlink(restart_name);
}
INT_PTR utils_setSafetyMode(WPARAM wParam, LPARAM lParam) {
int safeMode = (int)wParam;
log1("db_setSafetyMode: %s", safeMode?"On":"Off");
if (safeMode)
sql_exec(g_sqlite, "PRAGMA synchronous = NORMAL;");
else
sql_exec(g_sqlite, "PRAGMA synchronous = OFF;");
return 0;
}
bool cpiPython::AutoLoad()
{
if (log_level < 1) { if(Log(0)) LogStream() << "Open dir: " << mScriptDir << endl; }
log1( "PY: Autoload Loading scripts from dir: %s\n", mScriptDir.c_str() );
string pathname, filename;
DIR *dir = opendir(mScriptDir.c_str());
if(!dir)
{
if (log_level < 1) { if(Log(1)) LogStream() << "Open dir error" << endl; }
log1( "PY: Autoload Failed to open directory\n" );
return false;
}
struct dirent *dent = NULL;
while(NULL != (dent=readdir(dir)))
{
filename = dent->d_name;
if((filename.size() > 4) && (StrCompare(filename,filename.size()-3,3,".py")==0))
{
pathname = mScriptDir + filename;
cPythonInterpreter *ip = new cPythonInterpreter (pathname);
if(!ip) continue;
mPython.push_back(ip);
if(ip->Init())
{
if (log_level < 1) { if(Log(1)) LogStream() << "Success loading Python script: " << filename << endl; }
log1( "PY: Autoload Success loading script: [ %d ] %s\n", ip->id, filename.c_str() );
}
else
{
if (log_level < 1) { if(Log(1)) LogStream() << "Failed loading Python script: " << filename << endl; }
log1( "PY: Autoload Failed loading script: [ %d ] %s\n", ip->id, filename.c_str() );
mPython.pop_back();
delete ip;
}
}
}
closedir(dir);
return true;
}
void FAST_FUNC read_leases(const char *file)
{
struct dyn_lease lease;
int64_t written_at, time_passed;
int fd;
#if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1
unsigned i = 0;
#endif
fd = open_or_warn(file, O_RDONLY);
if (fd < 0)
return;
if (full_read(fd, &written_at, sizeof(written_at)) != sizeof(written_at))
goto ret;
written_at = SWAP_BE64(written_at);
time_passed = time(NULL) - written_at;
/* Strange written_at, or lease file from old version of udhcpd
* which had no "written_at" field? */
if ((uint64_t)time_passed > 12 * 60 * 60)
goto ret;
while (full_read(fd, &lease, sizeof(lease)) == sizeof(lease)) {
//FIXME: what if it matches some static lease?
uint32_t y = ntohl(lease.lease_nip);
if (y >= server_config.start_ip && y <= server_config.end_ip) {
signed_leasetime_t expires = ntohl(lease.expires) - (signed_leasetime_t)time_passed;
if (expires <= 0)
continue;
/* NB: add_lease takes "relative time", IOW,
* lease duration, not lease deadline. */
if (add_lease(lease.lease_mac, lease.lease_nip,
expires,
lease.hostname, sizeof(lease.hostname)
) == 0
) {
bb_error_msg("too many leases while loading %s", file);
break;
}
#if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1
i++;
#endif
}
}
log1("Read %d leases", i);
ret:
close(fd);
}
static double errbd(double u, double* cx)
/* find bound on tail probability using mgf, cutoff
point returned to *cx */
{
double sum1, lj, ncj, x, y, xconst; int j, nj;
counter();
xconst = u * sigsq; sum1 = u * xconst; u = 2.0 * u;
for (j=r-1; j>=0; j--)
{
nj = n[j]; lj = lb[j]; ncj = nc[j];
x = u * lj; y = 1.0 - x;
xconst = xconst + lj * (ncj / y + nj) / y;
sum1 = sum1 + ncj * square(x / y)
+ nj * (square(x) / y + log1(-x, FALSE ));
}
*cx = xconst; return exp1(-0.5 * sum1);
}
