std::string CNetworkInterfaceLinux::GetCurrentDefaultGateway(void)
{
std::string result;
#if defined(TARGET_DARWIN)
FILE* pipe = popen("echo \"show State:/Network/Global/IPv4\" | scutil | grep Router", "r");
Sleep(100);
if (pipe)
{
std::string tmpStr;
char buffer[256] = {'\0'};
if (fread(buffer, sizeof(char), sizeof(buffer), pipe) > 0 && !ferror(pipe))
{
tmpStr = buffer;
if (tmpStr.length() >= 11)
result = tmpStr.substr(11);
}
pclose(pipe);
}
if (result.empty())
CLog::Log(LOGWARNING, "Unable to determine gateway");
#elif defined(TARGET_FREEBSD)
size_t needed;
int mib[6];
char *buf, *next, *lim;
char line[16];
struct rt_msghdr *rtm;
struct sockaddr *sa;
struct sockaddr_in *sockin;
mib[0] = CTL_NET;
mib[1] = PF_ROUTE;
mib[2] = 0;
mib[3] = 0;
mib[4] = NET_RT_DUMP;
mib[5] = 0;
if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
return result;
if ((buf = (char *)malloc(needed)) == NULL)
return result;
if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) {
free(buf);
return result;
}
lim = buf + needed;
for (next = buf; next < lim; next += rtm->rtm_msglen) {
rtm = (struct rt_msghdr *)next;
sa = (struct sockaddr *)(rtm + 1);
sa = (struct sockaddr *)(SA_SIZE(sa) + (char *)sa);
sockin = (struct sockaddr_in *)sa;
if (inet_ntop(AF_INET, &sockin->sin_addr.s_addr,
line, sizeof(line)) == NULL) {
free(buf);
return result;
}
result = line;
break;
}
free(buf);
#else
FILE* fp = fopen("/proc/net/route", "r");
if (!fp)
{
// TBD: Error
return result;
}
char* line = NULL;
char iface[16];
char dst[128];
char gateway[128];
size_t linel = 0;
int n;
int linenum = 0;
while (getdelim(&line, &linel, '\n', fp) > 0)
{
// skip first two lines
if (linenum++ < 1)
continue;
// search where the word begins
n = sscanf(line, "%16s %128s %128s",
iface, dst, gateway);
if (n < 3)
continue;
if (strcmp(iface, m_interfaceName.c_str()) == 0 &&
strcmp(dst, "00000000") == 0 &&
strcmp(gateway, "00000000") != 0)
{
unsigned char gatewayAddr[4];
int len = CNetwork::ParseHex(gateway, gatewayAddr);
if (len == 4)
{
struct in_addr in;
in.s_addr = (gatewayAddr[0] << 24) | (gatewayAddr[1] << 16) |
(gatewayAddr[2] << 8) | (gatewayAddr[3]);
result = inet_ntoa(in);
break;
}
}
}
free(line);
fclose(fp);
#endif
return result;
}
void *computervision_thread_main(void* data)
{
// Video Input
struct vid_struct vid;
vid.device = (char*)"/dev/video1";
vid.w=1280;
vid.h=720;
vid.n_buffers = 4;
if (video_init(&vid)<0) {
printf("Error initialising video\n");
computervision_thread_status = -1;
return 0;
}
// Frame Grabbing
struct img_struct* img_new = video_create_image(&vid);
// Frame Resizing
uint8_t quality_factor = IMAGE_QUALITY_FACTOR;
uint8_t dri_jpeg_header = 1;
struct img_struct small;
small.w = vid.w / IMAGE_DOWNSIZE_FACTOR;
small.h = vid.h / IMAGE_DOWNSIZE_FACTOR;
small.buf = (uint8_t*)malloc(small.w*small.h*2);
// Commpressed image buffer
uint8_t* jpegbuf = (uint8_t*)malloc(vid.h*vid.w*2);
// file index (search from 0)
int file_index = 0;
int microsleep = (int)(1000000. / IMAGE_FPS);
while (computer_vision_thread_command > 0)
{
usleep(microsleep);
video_grab_image(&vid, img_new);
// Resize
resize_uyuv(img_new, &small, IMAGE_DOWNSIZE_FACTOR);
// JPEG encode the image:
uint32_t image_format = FOUR_TWO_TWO; // format (in jpeg.h)
uint8_t* end = encode_image (small.buf, jpegbuf, quality_factor, image_format, small.w, small.h, dri_jpeg_header);
uint32_t size = end-(jpegbuf);
#if IMAGE_SAVE
FILE* save;
char save_name[128];
if (system("mkdir -p /data/video/images") == 0) {
// search available index (max is 99)
for ( ; file_index < 99; file_index++) {
printf("search %d\n",file_index);
sprintf(save_name,"/data/video/images/img_%02d.jpg",file_index);
// test if file exists or not
if (access(save_name, F_OK) == -1) {
printf("access\n");
save = fopen(save_name, "w");
if (save != NULL) {
fwrite(jpegbuf, sizeof(uint8_t), size, save);
fclose(save);
}
else {
printf("Error when opening file %s\n", save_name);
}
// leave for loop
break;
}
else {printf("file exists\n");}
}
}
#endif
// Fork process
int status;
pid_t pid = fork();
if (pid == 0) {
// Open process to send using netcat in child process
char nc_cmd[64];
sprintf(nc_cmd, "nc %s %d", IMAGE_SERVER_IP, IMAGE_SERVER_PORT);
FILE* netcat;
netcat = popen(nc_cmd, "w");
if (netcat != NULL) {
fwrite(jpegbuf, sizeof(uint8_t), size, netcat);
if (pclose(netcat) == 0) {
printf("Sending image succesfully\n");
}
}
else {
printf("Fail sending image\n");
}
exit(0);
}
else if (pid < 0) {
printf("Fork failed\n");
}
else {
// Parent is waiting for child to terminate
wait(&status);
}
}
printf("Thread Closed\n");
video_close(&vid);
computervision_thread_status = -100;
return 0;
}
int FPutFile(TRUSERID *handle,int iRequest,ST_PACK *rPack,int *pRetCode,char *szMsg)
{
//ST_SDPACK *psd;
int ret;
char szCmd[256] = "";
char filepath[256]="";
char sFileName[256]={0};
char chkdate[9] = "";
FILE *fp;
struct stat fst;
memset(&fst,0,sizeof fst);
printf("filetransfer:主动获取对账文件标志[%d]\n", rPack->lvol2);
if(rPack->lvol2==1) // 需主动获取对账文件
{
ret = Bank_Checkacc(handle,rPack,pRetCode,szMsg);
if(ret)
{
sprintf(szMsg, "FPutFile:下载对账文件请求失败,错误代码[%d]", ret);
printf(szMsg);
return -1;
}
printf("FPutFile:下载对账文件请求成功\n");
}
/* 重命名文件
将银行chkdate 那天的对账文件，改名为 sFileName
*/
sprintf(szCmd,"getbankchkfile.sh %s",rPack->vsmess);
printf("FPutFile:szCmd[%s]\n", szCmd);
if((fp = popen(szCmd, "r"))==NULL)
{
sprintf(szMsg, "exec cmd[%s] error",szCmd);
return -1;
}
char line[1024]={0};
char lastline[1024]={0};
while(!feof(fp))
{
memset(line,0,sizeof(line));
if(fgets(line, sizeof(line),fp)==NULL)
{
if(feof(fp))
break;
else
{
pclose(fp);
return -1;
}
}
strcpy(lastline,line);
if(strstr(line,"filename:")!=0)
{
strcpy(sFileName,line+strlen("filename:"));
break;
}
}
pclose(fp);
printf("FPutFile:sFileName[%s]\n", sFileName);
if(strlen(sFileName)<1)
{
printf("FPutFile:%s\n", lastline);
strcpy(szMsg,lastline);
return -1;
}
trim(sFileName);
printf("downfile:[%s]\n",sFileName);
stat(sFileName, &fst);
printf("filelen:%d\n", fst.st_size);
int maxlen = sizeof(ST_PACK) - 4;
if (maxlen > 4000)
maxlen = 4000;
fp = fopen(sFileName, "rb");
if (fp == NULL)
{
sprintf(szMsg, "Cannot open the file:<%s>!", sFileName);
return 9999;
}
ST_SDPACK *psd=(ST_SDPACK *)rPack;
if(fst.st_size>0)
{
while (!feof(fp))
{
psd->usDataLength = fread(psd->data, 1, maxlen, fp);
PutRowData(rPack);
}
}
fclose(fp);
ST_CPACK aPack;
ST_PACK *outPack = &(aPack.pack);
ResetNormalCPack(&aPack,0,1);
SetCol(handle,0);
SetCol(handle,F_LVOL0,F_VSVARSTR0,F_VSMESS, 0);
outPack->lvol0 = fst.st_size;
strcpy(outPack->vsvarstr0, sFileName);
strcpy(outPack->vsmess, szMsg);
PutRow(handle, outPack, pRetCode, szMsg);
return 0;
}
// Fetch the X library directory, using xmkmf(1)
static const _XtString xlibdir(Display *display, bool verbose = false)
{
static bool tried = false;
static const _XtString dir = 0;
if (tried)
return dir;
tried = true;
if (!is_cmd_file(cmd_file("xmkmf")))
return dir; // No `xmkmf' in PATH
if (!is_cmd_file(cmd_file("make")))
return dir; // No `make' in PATH
static const char *shell_command =
""
#include "xlibdir.C"
"";
String me, my_class;
XtGetApplicationNameAndClass(display, &me, &my_class);
if (verbose)
{
std::cout << "Checking for X11 library directory... ";
std::cout.flush();
}
const string s1 = "/bin/sh -c " + sh_quote(shell_command);
FILE *fp = popen(s1.chars(), "r");
if (fp == 0)
{
if (verbose)
{
std::cout << strerror(errno) << "\n";
std::cout.flush();
}
return dir;
}
char buffer[PATH_MAX];
buffer[0] = '\0';
fgets(buffer, sizeof(buffer), fp);
pclose(fp);
int len = strlen(buffer);
if (len > 0 && buffer[len - 1] == '\n')
buffer[len - 1] = '\0';
if (buffer[0] == '/') // Sanity check
dir = (String)XtNewString(buffer);
if (verbose)
{
if (dir)
std::cout << dir << "\n";
else
std::cout << "(not found)\n";
std::cout.flush();
}
return dir;
}
bool generate_sql_makefile()
{
if (new_sql_updates.empty()) return true;
// find all files in the update dir
snprintf(cmd, MAX_CMD, "git show HEAD:%s", sql_update_dir);
if ((cmd_pipe = popen(cmd, "r")) == NULL)
return false;
// skip first two lines
if (!fgets(buffer, MAX_BUF, cmd_pipe)) { pclose(cmd_pipe); return false; }
if (!fgets(buffer, MAX_BUF, cmd_pipe)) { pclose(cmd_pipe); return false; }
char newname[MAX_PATH];
std::set<std::string> file_list;
sql_update_info info;
while (fgets(buffer, MAX_BUF, cmd_pipe))
{
buffer[strlen(buffer) - 1] = '\0';
if (buffer[strlen(buffer) - 1] != '/' &&
strncmp(buffer, "Makefile.am", MAX_BUF) != 0)
{
if (new_sql_updates.find(buffer) != new_sql_updates.end())
{
if (!get_sql_update_info(buffer, info)) return false;
snprintf(newname, MAX_PATH, REV_PRINT "_%s_%0*d_%s%s%s.sql", rev, info.parentRev, 2, info.nr, info.db, info.has_table ? "_" : "", info.table);
file_list.insert(newname);
}
else
file_list.insert(buffer);
}
}
pclose(cmd_pipe);
// write the makefile
char file_name[MAX_PATH];
snprintf(file_name, MAX_PATH, "%s%s/Makefile.am", path_prefix, sql_update_dir);
FILE* fout = fopen(file_name, "w");
if (!fout) { pclose(cmd_pipe); return false; }
fprintf(fout,
"# This code is part of MaNGOS. Contributor & Copyright details are in AUTHORS/THANKS.\n"
"#\n"
"# This program is free software; you can redistribute it and/or modify\n"
"# it under the terms of the GNU General Public License as published by\n"
"# the Free Software Foundation; either version 2 of the License, or\n"
"# (at your option) any later version.\n"
"#\n"
"# This program is distributed in the hope that it will be useful,\n"
"# but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
"# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
"# GNU General Public License for more details.\n"
"#\n"
"# You should have received a copy of the GNU General Public License\n"
"# along with this program; if not, write to the Free Software\n"
"# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
"\n"
"## Process this file with automake to produce Makefile.in\n"
"\n"
"## Sub-directories to parse\n"
"SUBDIRS = before_upgrade_to_0.13\n"
"\n"
"## Change installation location\n"
"# datadir = mangos/%s\n"
"pkgdatadir = $(datadir)/mangos/%s\n"
"\n"
"## Files to be installed\n"
"# Install basic SQL files to datadir\n"
"pkgdata_DATA = \\\n",
sql_update_dir, sql_update_dir
);
for(std::set<std::string>::iterator itr = file_list.begin(), next; itr != file_list.end(); ++itr)
{
next = itr; ++next;
fprintf(fout, "\t%s%s\n", itr->c_str(), next == file_list.end() ? "" : " \\");
}
fprintf(fout,
"\n## Additional files to include when running 'make dist'\n"
"# SQL update files, to upgrade database schema from older revisions\n"
"EXTRA_DIST = \\\n"
);
for (std::set<std::string>::iterator itr = file_list.begin(), next; itr != file_list.end(); ++itr)
{
next = itr; ++next;
fprintf(fout, "\t%s%s\n", itr->c_str(), next == file_list.end() ? "" : " \\");
}
fclose(fout);
snprintf(cmd, MAX_CMD, "git add %s%s/Makefile.am", path_prefix, sql_update_dir);
system_switch_index(cmd);
return true;
}
struct chipInfo_t *getChipInfo(const char *filename, int *num, uint32_t msmversion)
{
const char str1[] = "dtc -I dtb -O dts \"";
const char str2[] = "\" 2>&1";
char *buf, *pos;
char *line = NULL;
size_t line_size;
FILE *pfile;
int llen;
struct chipInfo_t *chip = NULL, *tmp;
uint32_t data[3] = {0, 0, 0};
uint32_t data_st[2] = {0, 0};
char *tok, *sptr = NULL;
int i, entryValid, entryEnded;
int count = 0, count1 = 0, count2 =0;
int entryValidST, entryEndedST, entryValidDT, entryEndedDT;
struct chipId_t *chipId = NULL, *cId = NULL, *tmp_id = NULL;
struct chipSt_t *chipSt = NULL, *cSt = NULL, *tmp_st = NULL;
line_size = 1024;
line = (char *)malloc(line_size);
if (!line) {
log_err("Out of memory\n");
return NULL;
}
llen = sizeof(char) * (strlen(dtc_path) +
strlen(str1) +
strlen(str2) +
strlen(filename) + 1);
buf = (char *)malloc(llen);
if (!buf) {
log_err("Out of memory\n");
free(line);
return NULL;
}
strncpy(buf, dtc_path, llen);
strncat(buf, str1, llen);
strncat(buf, filename, llen);
strncat(buf, str2, llen);
pfile = popen(buf, "r");
free(buf);
if (pfile == NULL) {
log_err("... skip, fail to decompile dtb\n");
} else {
/* Find "qcom,msm-id" */
while ((llen = getline(&line, &line_size, pfile)) != -1) {
if (msmversion == 1) {
if ((pos = strstr(line, dt_tag)) != NULL) {
pos += strlen(dt_tag);
entryEnded = 0;
while (1) {
entryValid = 1;
for (i = 0; i < 3; i++) {
tok = strtok_r(pos, " \t", &sptr);
pos = NULL;
if (tok != NULL) {
if (*tok == '>') {
entryEnded = 1;
entryValid = 0;
break;
}
data[i] = strtoul(tok, NULL, 0);
} else {
data[i] = 0;
entryValid = 0;
entryEnded = 1;
}
}
if (entryEnded) {
free(line);
pclose(pfile);
*num = count;
return chip;
}
if (entryValid) {
tmp = (struct chipInfo_t *)
malloc(sizeof(struct chipInfo_t));
if (!tmp) {
log_err("Out of memory\n");
break;
}
if (!chip) {
chip = tmp;
chip->t_next = NULL;
} else {
tmp->t_next = chip->t_next;
chip->t_next = tmp;
}
tmp->chipset = data[0];
tmp->platform = data[1];
tmp->subtype = 0;
tmp->revNum = data[2];
tmp->dtb_size = 0;
tmp->dtb_file = NULL;
tmp->master = chip;
tmp->wroteDtb = 0;
tmp->master_offset = 0;
count++;
}
}
log_err("... skip, incorrect '%s' format\n", dt_tag);
break;
}
} else if (msmversion == 2) {
if ((pos = strstr(line, dt_tag)) != NULL) {
pos += strlen(dt_tag);
entryEndedDT = 0;
for (;entryEndedDT < 1;) {
entryValidDT = 1;
for (i = 0; i < 2; i++) {
tok = strtok_r(pos, " \t", &sptr);
pos = NULL;
if (tok != NULL) {
if (*tok == '>') {
entryEndedDT = 1;
entryValidDT = 0;
break;
}
data_st[i] = strtoul(tok, NULL, 0);
} else {
data_st[i] = 0;
entryValidDT = 0;
entryEndedDT = 1;
}
}
if (entryValidDT) {
tmp_id = (struct chipId_t *)
malloc(sizeof(struct chipId_t));
if (!tmp_id) {
log_err("Out of memory\n");
break;
}
if (!chipId) {
chipId = tmp_id;
cId = tmp_id;
chipId->t_next = NULL;
} else {
tmp_id->t_next = chipId->t_next;
chipId->t_next = tmp_id;
}
tmp_id->chipset = data_st[0];
tmp_id->revNum= data_st[1];
count1++;
}
}
}
if ((pos = strstr(line,QCDT_BOARD_TAG)) != NULL) {
pos += strlen(QCDT_BOARD_TAG);
entryEndedST = 0;
for (;entryEndedST < 1;) {
entryValidST = 1;
for (i = 0; i < 2; i++) {
tok = strtok_r(pos, " \t", &sptr);
pos = NULL;
if (tok != NULL) {
if (*tok == '>') {
entryEndedST = 1;
entryValidST = 0;
break;
}
data_st[i] = strtoul(tok, NULL, 0);
} else {
data_st[i] = 0;
entryValidST = 0;
entryEndedST = 1;
}
}
if (entryValidST) {
tmp_st = (struct chipSt_t *)
malloc(sizeof(struct chipSt_t));
if (!tmp_st) {
log_err("Out of memory\n");
break;
}
if (!chipSt) {
chipSt = tmp_st;
cSt = tmp_st;
chipSt->t_next = NULL;
} else {
tmp_st->t_next = chipSt->t_next;
chipSt->t_next = tmp_st;
}
tmp_st->platform = data_st[0];
tmp_st->subtype= data_st[1];
count2++;
}
}
}
}
}
}
if (line)
free(line);
if (force_v2 || msmversion == 2) {
if (count1 == 0) {
log_err("... skip, incorrect '%s' format\n", dt_tag);
return NULL;
}
if (count2 == 0) {
log_err("... skip, incorrect '%s' format\n", QCDT_BOARD_TAG);
return NULL;
}
tmp_st = cSt;
while (cId != NULL) {
while (cSt != NULL) {
tmp = (struct chipInfo_t *)
malloc(sizeof(struct chipInfo_t));
if (!tmp) {
log_err("Out of memory\n");
break;
}
if (!chip) {
chip = tmp;
chip->t_next = NULL;
} else {
tmp->t_next = chip->t_next;
chip->t_next = tmp;
}
tmp->chipset = cId->chipset;
tmp->platform = cSt->platform;
tmp->revNum = cId->revNum;
tmp->subtype = cSt->subtype;
tmp->dtb_size = 0;
tmp->dtb_file = NULL;
tmp->master = chip;
tmp->wroteDtb = 0;
tmp->master_offset = 0;
cSt = cSt->t_next;
}
cSt = tmp_st;
cId = cId->t_next;
}
if (entryEndedST == 1 && entryEndedDT == 1) {
pclose(pfile);
*num = count1;
free(chipSt);
free(chipId);
return chip;
}
} else {
pclose(pfile);
}
return NULL;
}
/* Reads the output of command into buffer then inserts into a MESSAGE struct. */
void nonInteractive_appendClipboardContents( MESSAGE *msg, char *command ) {
/* Loop to the end of the message */
msg = msg->root;
for ( ; msg->next; msg = msg->next )
;
/* Allocate and move to new node */
msg->next = list_getNode( msg );
msg = msg->next;
/* Get and set path and time information */
list_setPath( msg );
list_setTime( msg );
char *tmp, *buffer;
tmp = buffer = NULL;
int buffSize, ch, charsRead;
buffSize = 1024;
charsRead = 0;
buffer = malloc( buffSize * sizeof(char) );
if ( !buffer ) {
fprintf( stderr,
"Failed to allocate memory for message buffer in nonInteractive_appendClipboardContents\n" );
exit( 1 );
}
FILE *fp;
/* Open the command for reading. */
fp = popen( command, "r" );
if ( fp == NULL ) {
printf( "Failed to run command\n" );
exit( 1 );
}
while ( ( ch = fgetc( fp ) ) != EOF ) {
/* If we've outgrown the buffer then allocate some more memory */
if ( charsRead >= buffSize ) {
buffSize *= 2;
tmp = realloc( buffer, buffSize * sizeof(char *) );
if ( !tmp ) {
fprintf( stderr,
"Failed to allocate %d bytes in nonInteractive_appendMessage\n",
buffSize );
exit( 1 );
} else {
buffer = tmp;
}
} else {
/* Otherwise add the character to the buffer and increment charsRead */
buffer[charsRead] = ch;
charsRead++;
}
}
/* Insert the buffer contents into a MESSAGE struct */
list_insertString( msg, buffer );
free( buffer );
pclose( fp );
}
bool MapnikRenderer::Preprocess( IImporter* importer, QString dir )
{
QString filename = fileInDirectory( dir, "Mapnik Renderer" );
try {
IImporter::BoundingBox box;
if ( !importer->GetBoundingBox( &box ) )
return false;
std::vector< IImporter::RoutingEdge > inputEdges;
std::vector< IImporter::RoutingNode > inputNodes;
std::vector< IImporter::RoutingNode > inputPaths;
if ( m_settings.deleteTiles ) {
if ( !importer->GetRoutingEdges( &inputEdges ) ) {
qCritical() << "Mapnik Renderer: failed to read routing edges";
return false;
}
if ( !importer->GetRoutingNodes( &inputNodes ) ) {
qCritical() << "Mapnik Renderer: failed to read routing nodes";
return false;
}
if ( !importer->GetRoutingEdgePaths( &inputPaths ) ) {
qCritical() << "Mapnik Renderer: failed to read routing paths";
}
}
Timer time;
mapnik::datasource_cache::instance().register_datasources( m_settings.plugins.toLatin1().constData() );
QDir fonts( m_settings.fonts );
mapnik::projection projection( "+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs +over" );
mapnik::freetype_engine::register_font( fonts.filePath( "DejaVuSans.ttf" ).toLatin1().constData() );
mapnik::freetype_engine::register_font( fonts.filePath( "DejaVuSans-Bold.ttf" ).toLatin1().constData() );
mapnik::freetype_engine::register_font( fonts.filePath( "DejaVuSans-Oblique.ttf" ).toLatin1().constData() );
mapnik::freetype_engine::register_font( fonts.filePath( "DejaVuSans-BoldOblique.ttf" ).toLatin1().constData() );
qDebug() << "Mapnik Renderer: initialized mapnik connection:" << time.restart() << "ms";
int numThreads = omp_get_max_threads();
qDebug() << "Mapnik Renderer: using" << numThreads << "threads";
qDebug() << "Mapnik Renderer: x: " << box.min.x << "-" << box.max.x;
qDebug() << "Mapnik Renderer: y: " << box.min.y << "-" << box.max.y;
FileStream configData( filename );
if ( !configData.open( QIODevice::WriteOnly ) )
return false;
configData << quint32( m_settings.tileSize ) << quint32( m_settings.zoomLevels.size() );
long long tilesSkipped = 0;
long long tiles = 0;
long long metaTilesRendered = 0;
long long pngcrushSaved = 0;
std::vector< ZoomInfo > zoomInfo( m_settings.zoomLevels.size() );
std::vector< MetaTile > tasks;
for ( int zoomLevel = 0; zoomLevel < ( int ) m_settings.zoomLevels.size(); zoomLevel++ ) {
ZoomInfo& info = zoomInfo[zoomLevel];
int zoom = m_settings.zoomLevels[zoomLevel];
info.minX = box.min.GetTileX( zoom );
info.maxX = box.max.GetTileX( zoom ) + 1;
info.minY = box.min.GetTileY( zoom );
info.maxY = box.max.GetTileY( zoom ) + 1;
if ( zoom <= m_settings.fullZoom ) {
info.minX = info.minY = 0;
info.maxX = info.maxY = 1 << zoom;
} else {
info.minX = std::max( 0 , info.minX - m_settings.tileMargin );
info.maxX = std::min ( 1 << zoom, info.maxX + m_settings.tileMargin );
info.minY = std::max( 0, info.minY - m_settings.tileMargin );
info.maxY = std::min ( 1 << zoom, info.maxY + m_settings.tileMargin );
}
tiles += ( info.maxX - info.minX ) * ( info.maxY - info.minY );
qDebug() << "Mapnik Renderer: [" << zoom << "] x:" << info.minX << "-" << info.maxX << "; y:" << info.minY << "-" << info.maxY;
configData << quint32( zoom ) << quint32( info.minX ) << quint32( info.maxX ) << quint32( info.minY ) << quint32( info.maxY );
int numberOfTiles = ( info.maxX - info.minX ) * ( info.maxY - info.minY );
IndexElement dummyIndex;
dummyIndex.start = dummyIndex.size = 0;
info.index.resize( numberOfTiles, dummyIndex );
std::vector< UnsignedCoordinate > path;
for ( std::vector< IImporter::RoutingEdge >::const_iterator i = inputEdges.begin(), e = inputEdges.end(); i != e; ++i ) {
path.push_back( inputNodes[i->source].coordinate );
for ( int pathID = 0; pathID < i->pathLength; pathID++ )
path.push_back( inputPaths[pathID + i->pathID].coordinate );
path.push_back( inputNodes[i->target].coordinate );
for ( unsigned edge = 0; edge < path.size(); edge++ ) {
int sourceX = path[edge].GetTileX( zoom );
int sourceY = path[edge].GetTileY( zoom );
int targetX = path[edge].GetTileX( zoom );
int targetY = path[edge].GetTileY( zoom );
if ( sourceX > targetX )
std::swap( sourceX, targetX );
if ( sourceY > targetY )
std::swap( sourceY, targetY );
sourceX = std::max( sourceX, info.minX );
sourceX = std::min( sourceX, info.maxX - 1 );
sourceY = std::max( sourceY, info.minY );
sourceY = std::min( sourceY, info.maxY - 1 );
targetX = std::max( targetX, info.minX );
targetX = std::min( targetX, info.maxX - 1 );
targetY = std::max( targetY, info.minY );
targetY = std::min( targetY, info.maxY - 1 );
for ( int x = sourceX; x <= targetX; ++x )
for ( int y = sourceY; y <= targetY; ++y )
info.index[( x - info.minX ) + ( y - info.minY ) * ( info.maxX - info.minX )].size = 1;
}
path.clear();
}
info.tilesFile = new QFile( filename + QString( "_%1_tiles" ).arg( zoom ) );
if ( !openQFile( info.tilesFile, QIODevice::WriteOnly ) )
return false;
for ( int x = info.minX; x < info.maxX; x+= m_settings.metaTileSize ) {
int metaTileSizeX = std::min( m_settings.metaTileSize, info.maxX - x );
for ( int y = info.minY; y < info.maxY; y+= m_settings.metaTileSize ) {
int metaTileSizeY = std::min( m_settings.metaTileSize, info.maxY - y );
MetaTile tile;
tile.zoom = zoomLevel;
tile.x = x;
tile.y = y;
tile.metaTileSizeX = metaTileSizeX;
tile.metaTileSizeY = metaTileSizeY;
tasks.push_back( tile );
}
}
}
#pragma omp parallel
{
int threadID = omp_get_thread_num();
const int metaTileSize = m_settings.metaTileSize * m_settings.tileSize + 2 * m_settings.margin;
mapnik::Map map;
mapnik::image_32 image( metaTileSize, metaTileSize );
QTemporaryFile tempOut;
QTemporaryFile tempIn;
mapnik::load_map( map, m_settings.theme.toLocal8Bit().constData() );
#pragma omp for schedule( dynamic )
for ( int i = 0; i < ( int ) tasks.size(); i++ ) {
int metaTileSizeX = tasks[i].metaTileSizeX;
int metaTileSizeY = tasks[i].metaTileSizeY;
int x = tasks[i].x;
int y = tasks[i].y;
int zoomLevel = tasks[i].zoom;
int zoom = m_settings.zoomLevels[zoomLevel];
ZoomInfo& info = zoomInfo[zoomLevel];
map.resize( metaTileSizeX * m_settings.tileSize + 2 * m_settings.margin, metaTileSizeY * m_settings.tileSize + 2 * m_settings.margin );
ProjectedCoordinate drawTopLeft( x - 1.0 * m_settings.margin / m_settings.tileSize, y - 1.0 * m_settings.margin / m_settings.tileSize, zoom );
ProjectedCoordinate drawBottomRight( x + metaTileSizeX + 1.0 * m_settings.margin / m_settings.tileSize, y + metaTileSizeY + 1.0 * m_settings.margin / m_settings.tileSize, zoom );
GPSCoordinate drawTopLeftGPS = drawTopLeft.ToGPSCoordinate();
GPSCoordinate drawBottomRightGPS = drawBottomRight.ToGPSCoordinate();
projection.forward( drawTopLeftGPS.longitude, drawBottomRightGPS.latitude );
projection.forward( drawBottomRightGPS.longitude, drawTopLeftGPS.latitude );
mapnik::box2d<double> boundingBox( drawTopLeftGPS.longitude, drawTopLeftGPS.latitude, drawBottomRightGPS.longitude, drawBottomRightGPS.latitude );
map.zoom_to_box( boundingBox );
mapnik::agg_renderer<mapnik::image_32> renderer( map, image );
renderer.apply();
std::string data;
int skipped = 0;
int saved = 0;
for ( int subX = 0; subX < metaTileSizeX; ++subX ) {
for ( int subY = 0; subY < metaTileSizeY; ++subY ) {
int indexNumber = ( y + subY - info.minY ) * ( info.maxX - info.minX ) + x + subX - info.minX;
mapnik::image_view<mapnik::image_data_32> view = image.get_view( subX * m_settings.tileSize + m_settings.margin, subY * m_settings.tileSize + m_settings.margin, m_settings.tileSize, m_settings.tileSize );
std::string result;
if ( !m_settings.deleteTiles || info.index[( x + subX - info.minX ) + ( y + subY - info.minY ) * ( info.maxX - info.minX )].size == 1 ) {
if ( m_settings.reduceColors )
result = mapnik::save_to_string( view, "png256" );
else
result = mapnik::save_to_string( view, "png" );
if ( m_settings.pngcrush ) {
tempOut.open();
tempOut.write( result.data(), result.size() );
tempOut.flush();
tempIn.open();
pclose( popen( ( "pngcrush " + tempOut.fileName() + " " + tempIn.fileName() ).toUtf8().constData(), "r" ) );
QByteArray buffer = tempIn.readAll();
tempIn.close();
tempOut.close();
if ( buffer.size() != 0 && buffer.size() < ( int ) result.size() ) {
saved += result.size() - buffer.size();
result.assign( buffer.constData(), buffer.size() );
}
}
}
info.index[indexNumber].start = data.size();
info.index[indexNumber].size = result.size();
data += result;
}
}
qint64 position;
#pragma omp critical
{
position = info.tilesFile->pos();
info.tilesFile->write( data.data(), data.size() );
metaTilesRendered++;
tilesSkipped += skipped;
pngcrushSaved += saved;
qDebug() << "Mapnik Renderer: [" << zoom << "], thread" << threadID << ", metatiles:" << metaTilesRendered << "/" << tasks.size();
}
for ( int subX = 0; subX < metaTileSizeX; ++subX ) {
for ( int subY = 0; subY < metaTileSizeY; ++subY ) {
int indexNumber = ( y + subY - info.minY ) * ( info.maxX - info.minX ) + x + subX - info.minX;
info.index[indexNumber].start += position;
}
}
}
}
for ( int zoomLevel = 0; zoomLevel < ( int ) m_settings.zoomLevels.size(); zoomLevel++ ) {
const ZoomInfo& info = zoomInfo[zoomLevel];
int zoom = m_settings.zoomLevels[zoomLevel];
QFile indexFile( filename + QString( "_%1_index" ).arg( zoom ) );
if ( !openQFile( &indexFile, QIODevice::WriteOnly ) )
return false;
for ( int i = 0; i < ( int ) info.index.size(); i++ ) {
indexFile.write( ( const char* ) &info.index[i].start, sizeof( info.index[i].start ) );
indexFile.write( ( const char* ) &info.index[i].size, sizeof( info.index[i].size ) );
}
delete info.tilesFile;
}
if ( m_settings.deleteTiles )
qDebug() << "Mapnik Renderer: removed" << tilesSkipped << "tiles";
if ( m_settings.pngcrush )
qDebug() << "Mapnik Renderer: PNGcrush saved" << pngcrushSaved / 1024 / 1024 << "MB";
qDebug() << "Mapnik Renderer: finished:" << time.restart() << "ms";
} catch ( const mapnik::config_error & ex ) {
qCritical( "Mapnik Renderer: ### Configuration error: %s", ex.what() );
return false;
} catch ( const std::exception & ex ) {
qCritical( "Mapnik Renderer: ### STD error: %s", ex.what() );
return false;
} catch ( ... ) {
qCritical( "Mapnik Renderer: ### Unknown error" );
return false;
}
return true;
}
/* UtvGetSystemStats
Populates a CJSON struct with relevant system stats information
*/
UTV_RESULT UtvPlatformGetSystemStats( void* pVoidResponseData )
{
UTV_RESULT result = UTV_OK;
UTV_INT8 ubReadBuffer[1024];
FILE* fpVmStat;
UTV_UINT32 uiVmStatVer = 0;
FILE* fp;
UTV_UINT32 uiScanCount = 0;
UTV_UINT32 uiMemFree = 0;
UTV_UINT32 uiMemUsed = 0;
UTV_UINT32 uiMemTotal = 0;
UTV_UINT32 uiMemPercentUsed = 0;
UTV_UINT32 uiCpuUser = 0;
UTV_UINT32 uiCpuSystem = 0;
UTV_UINT32 uiCpuTotalUsed = 0;
cJSON* responseData = (cJSON*)pVoidResponseData;
cJSON* memObject = NULL;
cJSON* cpuObject = NULL;
if (NULL != responseData)
{
memset(ubReadBuffer, 0x00, sizeof(ubReadBuffer));
/* Get stats */
fpVmStat = popen( "vmstat", "r" );
if ( !fpVmStat )
{
result = UTV_FILE_OPEN_FAILS;
}
else
{
/* Parse first 2 headers... ignore this data */
fgets( ubReadBuffer, sizeof(ubReadBuffer), fpVmStat );
fgets( ubReadBuffer, sizeof(ubReadBuffer), fpVmStat );
if ( 0 == strncmp( ubReadBuffer, " r b w", strlen( " r b w" ) ) )
{
uiVmStatVer = 2;
}
else if ( 0 == strncmp( ubReadBuffer, " r b swpd", strlen( " r b swpd" ) ) )
{
uiVmStatVer = 3;
}
/* Parse actual stats */
fgets( ubReadBuffer, sizeof(ubReadBuffer), fpVmStat );
if ( 2 == uiVmStatVer )
{
uiScanCount = sscanf( ubReadBuffer,
"%*u %*u %*u %*u %lu %*u %*u %*u %*u %*u %*u %*u %*u %lu %lu",
&uiMemFree,
&uiCpuUser,
&uiCpuSystem );
}
else if ( 3 == uiVmStatVer )
{
uiScanCount = sscanf( ubReadBuffer,
"%*u %*u %*u %lu %*u %*u %*u %*u %*u %*u %*u %*u %lu %lu",
&uiMemFree,
&uiCpuUser,
&uiCpuSystem );
}
if ( 3 != uiScanCount )
{
result = UTV_READ_FAILS;
}
else
{
/* Calculate total used CPU */
uiCpuTotalUsed = uiCpuUser + uiCpuSystem;
}
pclose( fpVmStat );
fpVmStat = NULL;
fp = fopen( "/proc/meminfo", "r" );
if ( !fp )
{
result = UTV_FILE_OPEN_FAILS;
}
else
{
/* Parse lines */
fgets( ubReadBuffer, sizeof(ubReadBuffer), fp );
if ( 0 == sscanf( ubReadBuffer, "MemTotal: %lu", &uiMemTotal ) )
{
result = UTV_READ_FAILS;
}
else
{
/* Calculate memory percentage */
if ( 0 != uiMemTotal )
{
uiMemUsed = uiMemTotal - uiMemFree;
uiMemPercentUsed = round( ((float)uiMemUsed / (float)uiMemTotal) * 100 );
/* Populate JSON object */
memObject = cJSON_CreateObject();
cpuObject = cJSON_CreateObject();
cJSON_AddNumberToObject( memObject, "Percent Used", uiMemPercentUsed );
cJSON_AddNumberToObject( memObject, "Free (MB)", uiMemFree );
cJSON_AddNumberToObject( memObject, "Used (MB)", uiMemUsed );
cJSON_AddNumberToObject( memObject, "Total (MB)", uiMemTotal );
cJSON_AddNumberToObject( cpuObject, "Total Percent Used", uiCpuTotalUsed );
cJSON_AddNumberToObject( cpuObject, "User Percent Used", uiCpuUser );
cJSON_AddNumberToObject( cpuObject, "System Percent Used", uiCpuSystem );
cJSON_AddItemToObject( responseData, "Memory", memObject );
cJSON_AddItemToObject( responseData, "CPU", cpuObject );
}
}
fclose( fp );
}
}
}
else
{
result = UTV_INVALID_PARAMETER;
}
return ( result );
}
int main(int argc, char *argv[])
{
int rtn;
int v;
FILE *fp;
unsigned char b[S_BUF];
char *tp;
int i_port_no;
int shtdwn;
struct option long_opts[] = {
{"input", 1, NULL, 0},
{"time", 1, NULL, 1},
{0, 0, 0, 0}
};
int res = 0;
int idx = 0;
while((res = getopt_long_only(argc, argv, "it", long_opts, &idx)) != EOD) {
switch(res) {
case 0: /* input */
DPRINT("input opt\n");
DPRINT("name=%s val=%s\n",long_opts[idx].name, optarg);
i_port_no = atoi(optarg);
if(i_port_no == 0) { /* 0 : not number */
fprintf(stderr, "Parameter not number : %s\n",optarg);
}
break;
case 1: /* time */
DPRINT("time opt\n");
DPRINT("name=%s val=%s\n",long_opts[idx].name, optarg);
shtdwn = atoi(optarg);
if(shtdwn == 0) { /* 0 : not number */
fprintf(stderr, "Parameter not number : %s\n",optarg);
}
break;
case 'i':
case 't':
break;
}
}
DPRINT("idx=%d\n",idx);
if( argc == 1 ) {
/* default */
i_port_no = INPUT_PORT;
shtdwn = SHTDWN;
} else {
if(idx == 0 || i_port_no == 0 || shtdwn == 0) {
fprintf(stderr, "Usage:%s\n",CMDNAME);
fprintf(stderr, " %s --input <port No.> --time <shutdown>\n",CMDNAME);
fprintf(stderr, " %s --input=<port No.> --time=<shutdown>\n",CMDNAME);
fprintf(stderr, " (default:--input 24 --time 30)\n");
return 1;
}
}
/* No allow dup run */
memset(b,0,S_BUF);
DPRINT("PSNAME=%s\n",PSNAME);
fp = popen(PSNAME, "r");
if(fp == NULL) {
fprintf(stderr, "fopen():Open Error.\n");
return 1;
} else {
/*fgets(b, S_BUF, fp);*/
fread(b, 1, S_BUF, fp);
pclose(fp);
DPRINT("val:\n%s",b);
tp = strstr(b, CMDNAME);
DPRINT("tp:\n%s",tp);
DPRINT("strlen(tp)=%d\n",strlen(tp));
if(strlen(tp) == strlen(CMDNAME)+1) {
DPRINT("One Process running.\n");
} else {
/* No allow dup run */
fprintf(stderr, "Two Processes running Error. Stop.\n");
return 0; /* normal */
}
}
rtn = wiringPiSetupGpio();
if( rtn == -1 ) {
fprintf(stderr, "wiringPiSetupGpio(): Error (%d)\n", rtn);
return 1;
}
pullUpDnControl(i_port_no, PUD_UP); /* pullup */
pinMode(i_port_no, INPUT);
v = 0;
v = digitalRead(i_port_no);
DPRINT("val=%d\n", v);
/* SW ON */
if(v == 0) { /* 0=ON 1=OFF:because pullup */
sleep(shtdwn);
system("/usr/bin/sudo /sbin/shutdown -h now");
}
return 0;
}
// dtor closes the pipe
~wxStdioPipe()
{
if ( m_fp )
pclose(m_fp);
}
int
convert (DB_playItem_t *it, const char *outfolder, const char *outfile, int output_bps, int output_is_float, int preserve_folder_structure, const char *root_folder, ddb_encoder_preset_t *encoder_preset, ddb_dsp_preset_t *dsp_preset, int *abort) {
if (deadbeef->pl_get_item_duration (it) <= 0) {
deadbeef->pl_lock ();
const char *fname = deadbeef->pl_find_meta (it, ":URI");
fprintf (stderr, "converter: stream %s doesn't have finite length, skipped\n", fname);
deadbeef->pl_unlock ();
return -1;
}
char *path = outfolder[0] ? strdupa (outfolder) : strdupa (getenv("HOME"));
if (!check_dir (path, 0755)) {
fprintf (stderr, "converter: failed to create output folder: %s\n", outfolder);
return -1;
}
int err = -1;
FILE *enc_pipe = NULL;
FILE *temp_file = NULL;
DB_decoder_t *dec = NULL;
DB_fileinfo_t *fileinfo = NULL;
char out[PATH_MAX] = ""; // full path to output file
char input_file_name[PATH_MAX] = "";
dec = (DB_decoder_t *)deadbeef->plug_get_for_id (deadbeef->pl_find_meta (it, ":DECODER"));
if (dec) {
fileinfo = dec->open (0);
if (fileinfo && dec->init (fileinfo, DB_PLAYITEM (it)) != 0) {
deadbeef->pl_lock ();
fprintf (stderr, "converter: failed to decode file %s\n", deadbeef->pl_find_meta (it, ":URI"));
deadbeef->pl_unlock ();
goto error;
}
if (fileinfo) {
if (output_bps == -1) {
output_bps = fileinfo->fmt.bps;
output_is_float = fileinfo->fmt.is_float;
}
get_output_path (it, outfolder, outfile, encoder_preset, out, sizeof (out));
if (encoder_preset->method == DDB_ENCODER_METHOD_FILE) {
const char *tmp = getenv ("TMPDIR");
if (!tmp) {
tmp = "/tmp";
}
snprintf (input_file_name, sizeof (input_file_name), "%s/ddbconvXXXXXX", tmp);
mktemp (input_file_name);
strcat (input_file_name, ".wav");
}
else {
strcpy (input_file_name, "-");
}
char enc[2000];
memset (enc, 0, sizeof (enc));
// formatting: %o = outfile, %i = infile
char *e = encoder_preset->encoder;
char *o = enc;
*o = 0;
int len = sizeof (enc);
while (e && *e) {
if (len <= 0) {
fprintf (stderr, "converter: failed to assemble encoder command line - buffer is not big enough, try to shorten your parameters. max allowed length is %u characters\n", (unsigned)sizeof (enc));
goto error;
}
if (e[0] == '%' && e[1]) {
if (e[1] == 'o') {
int l = snprintf (o, len, "\"%s\"", out);
o += l;
len -= l;
}
else if (e[1] == 'i') {
int l = snprintf (o, len, "\"%s\"", input_file_name);
o += l;
len -= l;
}
else {
strncpy (o, e, 2);
o += 2;
len -= 2;
}
e += 2;
}
else {
*o++ = *e++;
*o = 0;
len--;
}
}
fprintf (stderr, "converter: will encode using: %s\n", enc[0] ? enc : "internal RIFF WAVE writer");
if (!encoder_preset->encoder[0]) {
// write to wave file
temp_file = fopen (out, "w+b");
if (!temp_file) {
fprintf (stderr, "converter: failed to open output wave file %s\n", out);
goto error;
}
}
else if (encoder_preset->method == DDB_ENCODER_METHOD_FILE) {
temp_file = fopen (input_file_name, "w+b");
if (!temp_file) {
fprintf (stderr, "converter: failed to open temp file %s\n", input_file_name);
goto error;
}
}
else {
enc_pipe = popen (enc, "w");
if (!enc_pipe) {
fprintf (stderr, "converter: failed to open encoder\n");
goto error;
}
}
if (!temp_file) {
temp_file = enc_pipe;
}
// write wave header
char wavehdr_int[] = {
0x52, 0x49, 0x46, 0x46, 0x24, 0x70, 0x0d, 0x00, 0x57, 0x41, 0x56, 0x45, 0x66, 0x6d, 0x74, 0x20, 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x44, 0xac, 0x00, 0x00, 0x10, 0xb1, 0x02, 0x00, 0x04, 0x00, 0x10, 0x00, 0x64, 0x61, 0x74, 0x61
};
char wavehdr_float[] = {
0x52, 0x49, 0x46, 0x46, 0x2a, 0xdf, 0x02, 0x00, 0x57, 0x41, 0x56, 0x45, 0x66, 0x6d, 0x74, 0x20, 0x28, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x02, 0x00, 0x40, 0x1f, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x00, 0x08, 0x00, 0x20, 0x00, 0x16, 0x00, 0x20, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71, 0x66, 0x61, 0x63, 0x74, 0x04, 0x00, 0x00, 0x00, 0xc5, 0x5b, 0x00, 0x00, 0x64, 0x61, 0x74, 0x61
};
char *wavehdr = output_is_float ? wavehdr_float : wavehdr_int;
int wavehdr_size = output_is_float ? sizeof (wavehdr_float) : sizeof (wavehdr_int);
int header_written = 0;
uint32_t outsize = 0;
uint32_t outsr = fileinfo->fmt.samplerate;
uint16_t outch = fileinfo->fmt.channels;
int samplesize = fileinfo->fmt.channels * fileinfo->fmt.bps / 8;
int bs = 10250 * samplesize;
char buffer[bs * 4];
int dspsize = bs / samplesize * sizeof (float) * fileinfo->fmt.channels;
char dspbuffer[dspsize * 4];
int eof = 0;
for (;;) {
if (eof) {
break;
}
if (abort && *abort) {
break;
}
int sz = dec->read (fileinfo, buffer, bs);
if (sz != bs) {
eof = 1;
}
if (dsp_preset) {
ddb_waveformat_t fmt;
ddb_waveformat_t outfmt;
memcpy (&fmt, &fileinfo->fmt, sizeof (fmt));
memcpy (&outfmt, &fileinfo->fmt, sizeof (fmt));
fmt.bps = 32;
fmt.is_float = 1;
deadbeef->pcm_convert (&fileinfo->fmt, buffer, &fmt, dspbuffer, sz);
ddb_dsp_context_t *dsp = dsp_preset->chain;
int frames = sz / samplesize;
while (dsp) {
frames = dsp->plugin->process (dsp, (float *)dspbuffer, frames, sizeof (dspbuffer) / (fmt.channels * 4), &fmt, NULL);
dsp = dsp->next;
}
outsr = fmt.samplerate;
outch = fmt.channels;
outfmt.bps = output_bps;
outfmt.is_float = output_is_float;
outfmt.channels = outch;
outfmt.samplerate = outsr;
int n = deadbeef->pcm_convert (&fmt, dspbuffer, &outfmt, buffer, frames * sizeof (float) * fmt.channels);
sz = n;
}
else if (fileinfo->fmt.bps != output_bps || fileinfo->fmt.is_float != output_is_float) {
ddb_waveformat_t outfmt;
memcpy (&outfmt, &fileinfo->fmt, sizeof (outfmt));
outfmt.bps = output_bps;
outfmt.is_float = output_is_float;
outfmt.channels = outch;
outfmt.samplerate = outsr;
int frames = sz / samplesize;
int n = deadbeef->pcm_convert (&fileinfo->fmt, buffer, &outfmt, dspbuffer, frames * samplesize);
memcpy (buffer, dspbuffer, n);
sz = n;
}
outsize += sz;
if (!header_written) {
uint32_t size = (it->endsample-it->startsample) * outch * output_bps / 8;
if (!size) {
size = deadbeef->pl_get_item_duration (it) * fileinfo->fmt.samplerate * outch * output_bps / 8;
}
if (outsr != fileinfo->fmt.samplerate) {
uint64_t temp = size;
temp *= outsr;
temp /= fileinfo->fmt.samplerate;
size = temp;
}
memcpy (&wavehdr[22], &outch, 2);
memcpy (&wavehdr[24], &outsr, 4);
uint16_t blockalign = outch * output_bps / 8;
memcpy (&wavehdr[32], &blockalign, 2);
memcpy (&wavehdr[34], &output_bps, 2);
fwrite (wavehdr, 1, wavehdr_size, temp_file);
if (encoder_preset->method == DDB_ENCODER_METHOD_PIPE) {
size = 0;
}
fwrite (&size, 1, sizeof (size), temp_file);
header_written = 1;
}
int64_t res = fwrite (buffer, 1, sz, temp_file);
if (sz != res) {
fprintf (stderr, "converter: write error (%lld bytes written out of %d)\n", res, sz);
goto error;
}
}
if (abort && *abort) {
goto error;
}
if (temp_file && temp_file != enc_pipe) {
fseek (temp_file, wavehdr_size, SEEK_SET);
fwrite (&outsize, 1, 4, temp_file);
fclose (temp_file);
temp_file = NULL;
}
if (encoder_preset->encoder[0] && encoder_preset->method == DDB_ENCODER_METHOD_FILE) {
enc_pipe = popen (enc, "w");
}
}
}
err = 0;
error:
if (temp_file && temp_file != enc_pipe) {
fclose (temp_file);
temp_file = NULL;
}
if (enc_pipe) {
pclose (enc_pipe);
enc_pipe = NULL;
}
if (dec && fileinfo) {
dec->free (fileinfo);
fileinfo = NULL;
}
if (abort && *abort && out[0]) {
unlink (out);
}
if (input_file_name[0] && strcmp (input_file_name, "-")) {
unlink (input_file_name);
}
// write junklib tags
uint32_t tagflags = JUNK_STRIP_ID3V2 | JUNK_STRIP_APEV2 | JUNK_STRIP_ID3V1;
if (encoder_preset->tag_id3v2) {
tagflags |= JUNK_WRITE_ID3V2;
}
if (encoder_preset->tag_id3v1) {
tagflags |= JUNK_WRITE_ID3V1;
}
if (encoder_preset->tag_apev2) {
tagflags |= JUNK_WRITE_APEV2;
}
DB_playItem_t *out_it = deadbeef->pl_item_alloc ();
deadbeef->pl_item_copy (out_it, it);
deadbeef->pl_replace_meta (out_it, ":URI", out);
deadbeef->pl_delete_meta (out_it, "cuesheet");
deadbeef->junk_rewrite_tags (out_it, tagflags, encoder_preset->id3v2_version + 3, "iso8859-1");
// write flac tags
if (encoder_preset->tag_flac) {
// find flac decoder plugin
DB_decoder_t **plugs = deadbeef->plug_get_decoder_list ();
DB_decoder_t *flac = NULL;
for (int i = 0; plugs[i]; i++) {
if (!strcmp (plugs[i]->plugin.id, "stdflac")) {
flac = plugs[i];
break;
}
}
if (!flac) {
fprintf (stderr, "converter: flac plugin not found, cannot write flac metadata\n");
}
else {
if (0 != flac->write_metadata (out_it)) {
fprintf (stderr, "converter: failed to write flac metadata, not a flac file?\n");
}
}
}
// write vorbis tags
if (encoder_preset->tag_oggvorbis) {
// find flac decoder plugin
DB_decoder_t **plugs = deadbeef->plug_get_decoder_list ();
DB_decoder_t *ogg = NULL;
for (int i = 0; plugs[i]; i++) {
if (!strcmp (plugs[i]->plugin.id, "stdogg")) {
ogg = plugs[i];
break;
}
}
if (!ogg) {
fprintf (stderr, "converter: ogg plugin not found, cannot write ogg metadata\n");
}
else {
if (0 != ogg->write_metadata (out_it)) {
fprintf (stderr, "converter: failed to write ogg metadata, not an ogg file?\n");
}
}
}
deadbeef->pl_item_unref (out_it);
return err;
}
KaldiStream::~KaldiStream() {
if (_ffid) pclose(_ffid);
if (_lfid) pclose(_lfid);
}
bool wine_start(char *wine_app, char *avsloader, AVS_PIPES *avs_pipes, int pipe_timeout)
{
char sname[MAX_PATH];
struct stat st;
sprintf(sname, "%s %s %d", wine_app, avsloader, pipe_timeout);
FILE *pfile = popen(sname, "r");
if (!pfile)
{
DEBUG_PRINTF_RED("avsfilter : popen failed, errno %d, failed start app is : [%s]\n", errno, sname);
return false;
}
if (fscanf(pfile, "%s\n", sname) != 1 ||
stat(sname, &st) ||
!S_ISDIR(st.st_mode))
{
DEBUG_PRINTF_RED("avsfilter : tmpdirname [%s] failed, errno %d[stat %d isdir %d]\n", sname, errno, stat(sname, &st), S_ISDIR(st.st_mode));
pclose(pfile);
return false;
}
DEBUG_PRINTF("avsfilter : good tmpdirname %s\n", sname);
if (!init_pipes(avs_pipes, CMD_PIPE_NUM, pfile))
{
DEBUG_PRINTF_RED("init_pipes failed\n");
pclose(pfile);
return false;
}
time_t t = time(NULL);
DEBUG_PRINTF("avsfilter : precreate thread time %s\n",
ctime(&t));
pthread_t thread;
TPARSER tp = { avs_pipes, pfile };
open_pipes_ok = false;
if (pthread_create(&thread, NULL, parse_wine_stdout, &tp))
{
DEBUG_PRINTF_RED("Cannot pthread started...Errno %d\n",errno);
deinit_pipes(avs_pipes, CMD_PIPE_NUM);
return false;
}
t = time(NULL);
DEBUG_PRINTF("avsfilter : preopen time %s\n",
ctime(&t));
if (!open_pipes(avs_pipes, CMD_PIPE_NUM) || wine_loader_down)
{
open_pipes_ok = true;
DEBUG_PRINTF_RED("open_pipes failed\n");
deinit_pipes(avs_pipes, CMD_PIPE_NUM);
return false;
}
open_pipes_ok = true;
if (pipe_test_filter (avs_pipes[PIPE_LOADER_READ].hpipe,
avs_pipes[PIPE_FILTER_WRITE].hpipe))
{
DEBUG_PRINTF("avsfilter : test pipe to filter ok\n");
if (pipe_test_filter (avs_pipes[PIPE_LOADER_READ].hpipe,
avs_pipes[PIPE_LOADER_WRITE].hpipe))
{
DEBUG_PRINTF("avsfilter : test pipe to loader ok\n");
}
else
goto error_pipe_test;
}
else
{
error_pipe_test:
DEBUG_PRINTF_RED("Error test read/write pipes\n");
deinit_pipes(avs_pipes, CMD_PIPE_NUM);
return false;
}
DEBUG_PRINTF("wine start is ok\n");
return true;
}
int get_suggested_omp_num_threads() {
int default_num_threads=1, suggested_num_threads=1;
char* env_var_c;
env_var_c = getenv ("OMP_NUM_THREADS");
if(env_var_c)
{
return atoi(env_var_c);
}
// cout<<"OMP_NUM_THREADS is not defined"<<endl;
//set number of threads for appropriate OS
int avload, nbofproc=omp_get_num_procs();
FILE *iff;
#if defined(__APPLE__) || defined(__MACH__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__bsdi__) || defined(__DragonFly__)
cout<<"is MAC/*BSD"<<endl;
iff= popen("echo $(sysctl -n vm.loadavg|cut -d\" \" -f2)", "r");
if (!iff)
{
return default_num_threads;
}
#elif defined(__linux__) || defined(__gnu_linux__) || defined(linux)
iff= popen("cat /proc/loadavg |cut -d\" \" -f2", "r");
if (!iff)
{
return default_num_threads;
}
#elif defined (__unix) || (__unix__)
iff=freopen("/proc/loadavg","r",stderr);
fclose(stderr);
if(!iff)
{
cout<<"your OS is not supported"<<endl;
return default_num_threads;
}
iff= popen("cat /proc/loadavg 2>/dev/null|cut -d\" \" -f2", "r");
if (!iff)
{
return default_num_threads;
}
#elif defined(_WIN32) || defined(__WIN32__) || defined(__WINDOWS__)
iff= popen("wmic cpu get loadpercentage|more +1", "r");
if (!iff)
{
return default_num_threads;
}
char buffer[4];
char* c;
c=fgets(buffer, sizeof(buffer), iff);
if(!c)
{
return default_num_threads;
}
pclose(iff);
int cout=0;
while(buffer[count]!='\0' && buffer[count]!=' ')count++;
for(int i=1,j=1;i<=count;i++,j*=10)
avload+=(buffer[count-i]-'0')*j;
suggested_num_threads=nbofproc-(int)(avload*((float)nbofproc/100)+0.5);
return suggested_num_threads;
#else
cout<<"Can't define your OS"<<endl;
return default_num_threads;
#endif
char buffer[4];
char* c;
c=fgets(buffer, sizeof(buffer), iff);
if(!c)
{
return default_num_threads;
}
pclose(iff);
avload=(buffer[0]-'0')+((buffer[2]-'0')>5?1:0);
suggested_num_threads=nbofproc-avload;
return suggested_num_threads;
}
int main(int argc, char *argv[])
{
long brandID = 0;
Boolean AddUsers = false;
Boolean SetSavers = false;
Boolean isBMGroupMember, isBPGroupMember;
Boolean saverIsSet = false;
passwd *pw;
uid_t saved_uid;
group grpBOINC_master, *grpBOINC_masterPtr;
group grpBOINC_project, *grpBOINC_projectPtr;
char bmBuf[32768];
char bpBuf[32768];
char loginName[256];
short index, i;
FILE *f;
int flag;
char *p;
char s[1024], buf[1024];
OSStatus err;
brandID = GetBrandID();
#ifndef _DEBUG
if (getuid() != 0) {
printf("This program must be run as root\n");
printUsage(brandID);
return 0;
}
#endif
saved_uid = geteuid();
if (argc < 3) {
printUsage(brandID);
return 0;
}
if (strcmp(argv[1], "-a") == 0) {
AddUsers = true;
} else if (strcmp(argv[1], "-s") == 0) {
AddUsers = true;
SetSavers = true;
} else if (strcmp(argv[1], "-r") != 0) {
printUsage(brandID);
return 0;
}
printf("\n");
if (!check_branding_arrays(s, sizeof(s))) {
printf("Branding array has too few entries: %s\n", s);
return -1;
}
loginName[0] = '\0';
strncpy(loginName, getenv("USER"), sizeof(loginName)-1);
err = getgrnam_r("boinc_master", &grpBOINC_master, bmBuf, sizeof(bmBuf), &grpBOINC_masterPtr);
if (err) { // Should never happen unless buffer too small
puts("getgrnam(\"boinc_master\") failed\n");
return -1;
}
err = getgrnam_r("boinc_project", &grpBOINC_project, bpBuf, sizeof(bpBuf), &grpBOINC_projectPtr);
if (err) { // Should never happen unless buffer too small
puts("getgrnam(\"boinc_project\") failed\n");
return -1;
}
for (index=2; index<argc; index++) {
// getpwnam works with either the full / login name (pw->pw_gecos)
// or the short / Posix name (pw->pw_name)
pw = getpwnam(argv[index]);
if ((pw == NULL) || (pw->pw_uid < 501)) {
printf("User %s not found.\n\n", argv[index]);
continue;
}
flag = 0;
sprintf(s, "dscl . -read \"/Users/%s\" NFSHomeDirectory", pw->pw_name);
f = popen(s, "r");
if (!f) {
flag = 1;
} else {
while (PersistentFGets(buf, sizeof(buf), f)) {
p = strrchr(buf, ' ');
if (p) {
if (strstr(p, "/var/empty") != NULL) {
flag = 1;
break;
}
}
}
pclose(f);
}
if (flag) {
sprintf(s, "dscl . -read \"/Users/%s\" UserShell", pw->pw_name);
f = popen(s, "r");
if (!f) {
flag |= 2;
} else {
while (PersistentFGets(buf, sizeof(buf), f)) {
p = strrchr(buf, ' ');
if (p) {
if (strstr(p, "/usr/bin/false") != NULL) {
flag |= 2;
break;
}
}
}
pclose(f);
}
}
if (flag == 3) { // if (Home Directory == "/var/empty") && (UserShell == "/usr/bin/false")
printf("%s is not a valid user name.\n\n", argv[index]);
continue;
}
printf("%s user %s (/Users/%s)\n", AddUsers? "Adding" : "Removing", pw->pw_gecos, pw->pw_name);
isBMGroupMember = false;
i = 0;
while ((p = grpBOINC_master.gr_mem[i]) != NULL) { // Step through all users in group boinc_master
if (strcmp(p, pw->pw_name) == 0) { // Only the short / Posix names are in the list
// User is a member of group boinc_master
isBMGroupMember = true;
break;
}
++i;
}
isBPGroupMember = false;
i = 0;
while ((p = grpBOINC_project.gr_mem[i]) != NULL) { // Step through all users in group boinc_project
if (strcmp(p, pw->pw_name) == 0) { // Only the short / Posix names are in the list
// User is a member of group boinc_master
isBPGroupMember = true;
break;
}
++i;
}
if ((!isBMGroupMember) && AddUsers) {
sprintf(s, "dscl . -merge /groups/boinc_master GroupMembership %s", pw->pw_name);
callPosixSpawn(s);
}
if ((!isBPGroupMember) && AddUsers) {
sprintf(s, "dscl . -merge /groups/boinc_project GroupMembership %s", pw->pw_name);
callPosixSpawn(s);
}
if (isBMGroupMember && (!AddUsers)) {
sprintf(s, "dscl . -delete /Groups/boinc_master GroupMembership %s", pw->pw_name);
callPosixSpawn(s);
}
if (isBPGroupMember && (!AddUsers)) {
sprintf(s, "dscl . -delete /Groups/boinc_project GroupMembership %s", pw->pw_name);
callPosixSpawn(s);
}
if (!AddUsers) {
// Delete per-user BOINC Manager and screensaver files
sprintf(s, "rm -fR \"/Users/%s/Library/Application Support/BOINC\"", pw->pw_name);
callPosixSpawn (s);
}
// Set or remove login item for this user
bool useOSASript = false;
if ((compareOSVersionTo(10, 13) < 0)
|| (strcmp(loginName, pw->pw_name) == 0)
|| (strcmp(loginName, pw->pw_gecos) == 0)) {
useOSASript = true;
}
#if USE_OSASCRIPT_FOR_ALL_LOGGED_IN_USERS
if (! useOSASript) {
useOSASript = IsUserLoggedIn(pw->pw_name);
}
#endif
if (useOSASript) {
snprintf(s, sizeof(s), "/Users/%s/Library/LaunchAgents/edu.berkeley.boinc.plist", pw->pw_name);
boinc_delete_file(s);
SetLoginItemOSAScript(brandID, !AddUsers, pw->pw_name);
} else {
SetLoginItemLaunchAgent(brandID, !AddUsers, pw);
}
saverIsSet = false;
err = GetCurrentScreenSaverSelection(pw, s, sizeof(s) -1);
#if VERBOSE
fprintf(stderr, "Current Screensaver Selection for user %s is: \"%s\"\n", pw->pw_name, s);
#endif
if (err == noErr) {
if (!strcmp(s, saverName[brandID])) {
saverIsSet = true;
}
}
if (SetSavers) {
if (saverIsSet) {
printf("Screensaver already set to %s for user %s (/Users/%s)\n", saverName[brandID], pw->pw_gecos, pw->pw_name);
} else {
printf("Setting screensaver to %s for user %s (/Users/%s)\n", saverName[brandID], pw->pw_gecos, pw->pw_name);
}
}
if ((!saverIsSet) && SetSavers) {
seteuid(pw->pw_uid); // Temporarily set effective uid to this user
sprintf(s, "/Library/Screen Savers/%s.saver", saverName[brandID]);
err = SetScreenSaverSelection(pw, saverName[brandID], s, 0);
#if VERBOSE
fprintf(stderr, "SetScreenSaverSelection for user %s (uid %d) to \"%s\" returned error %d\n", pw->pw_name, geteuid(), saverName[brandID], err);
#endif
seteuid(saved_uid); // Set effective uid back to privileged user
// This seems to work also:
// sprintf(buf, "su -l \"%s\" -c 'defaults -currentHost write com.apple.screensaver moduleDict -dict moduleName \"%s\" path \"%s\ type 0'", pw->pw_name, saverName[brandID], s);
// callPosixSpawn(s);
}
if (saverIsSet && (!AddUsers)) {
printf("Setting screensaver to Flurry for user %s (/Users/%s)\n", pw->pw_gecos, pw->pw_name);
seteuid(pw->pw_uid); // Temporarily set effective uid to this user
err = SetScreenSaverSelection(pw, "Flurry", "/System/Library/Screen Savers/Flurry.saver", 0);
#if VERBOSE
fprintf(stderr, "SetScreenSaverSelection for user %s (%d) to Flurry returned error %d\n", pw->pw_name, geteuid(), err);
#endif
seteuid(saved_uid); // Set effective uid back to privileged user
}
seteuid(saved_uid); // Set effective uid back to privileged user
printf("\n");
}
printf("WARNING: Changes may require a system restart to take effect.\n");
return 0;
}
/* Main function */
int main ( int argc, char** argv)
{
/* Default settings for serial connection */
char *port = "/dev/ttyUSB0";
int baud = 57600;
/* Serial read buffer */
int bytes;
unsigned char buff[32];
/* Parse arguments */
int c;
while ((c = getopt (argc, argv, "a:p:b:h")) != -1) {
switch (c)
{
case 'a':
ac_id = atoi(optarg);
break;
case 'p':
port = optarg;
break;
case 'b':
baud = atoi(optarg);
break;
case 'h':
default:
printf("usage: sdlogger_download [options]\n"
" options:\n"
" -a \tAircraft ID\n"
" -p \tPort (default: /dev/ttyUSB0).\n"
" -b \tBaudrate (default: 57600).\n"
" -h \tHelp, shows this message.\n");
exit(0);
}
}
/* Obtain sd2log directory */
char *pprz_home;
pprz_home = getenv( "PAPARAZZI_HOME" );
strcat(sd2log, pprz_home);
strcat(sd2log, "/sw/logalizer/sd2log temp.tlm");
/* Get the setting ID with a python script */
/* TODO: would be nicer to have a C xml parser */
FILE *in = NULL;
//strcat(pycommand, pprz_home);
//strcat(pycommand, "/sw/logalizer/sdlogger_get_setting_id.py %u sdlogger_spi.command");
char new_command[256];
strcat(pycommand, "python sdlogger_get_setting_id.py %u sdlogger_spi.command");
sprintf(new_command, pycommand, ac_id);
strcpy(pycommand, new_command);
char returnvalue[128];
in = popen(pycommand, "r");
fgets(returnvalue, 128, in);
setting = atoi(returnvalue);
pclose(in);
if (setting == 0) {
printf("Aborting: %s\n", returnvalue);
exit(0);
}
/* Enable Ctrl+C */
signal(SIGINT, intHandler);
/* Open serial port */
printf("Opening port %s with baudrate B%i\n", port, baud);
if(serial_init(port, baud) < 0){
return -1;
}
/* Keep polling for logger */
printf("Searching for logger..");
time_t counter = time(0);
time_t timeout = 1; // every second
while (keep_running && searching) {
if (time(0) - counter >= timeout) {
printf(".");
fflush(stdout);
write_command(255);
global_state = WaitingForIndexRequestConfirmation;
counter = time(0);
}
else {
bytes = read(fd, (unsigned char*) buff, 32);
parse_bytes(buff, bytes);
usleep(5000);
}
}
char command[128];
strcpy(command, "help");
/* Show available commands */
printf("\n");
process_command(command);
while (keep_running) {
if (need_input) {
need_input = false;
/* Test user input */
printf("Command> ");
fgets (command, 128, stdin);
process_command(command);
}
else {
bytes = read(fd, (unsigned char*) buff, 32);
parse_bytes(buff, bytes);
}
}
printf("Closing app\n");
/* Close serial port */
close_port();
return 0;
}
// メイン処理
void run(const std::string& url, const std::string& name) {
// 接続およびエラーイベントのリスナを設定する
client.set_close_listener(std::bind(&SampleClient::on_close, this));
client.set_fail_listener(std::bind(&SampleClient::on_fail, this));
client.set_open_listener(std::bind(&SampleClient::on_open, this));
// 接続要求を出す
client.connect(url);
{ // 別スレッドで動く接続処理が終わるまで待つ
std::unique_lock<std::mutex> lock(sio_mutex);
if (!is_connected) {
sio_cond.wait(sio_mutex);
}
}
// "run"コマンドのリスナを登録する
socket = client.socket();
socket->on("run", std::bind(&SampleClient::on_run, this, std::placeholders::_1));
{
sio::message::ptr send_data(sio::object_message::create());
std::map<std::string, sio::message::ptr>& map = send_data->get_map();
// objectのメンバ、typeとnameを設定する
map.insert(std::make_pair("type", sio::string_message::create("native")));
map.insert(std::make_pair("name", sio::string_message::create(name)));
// joinコマンドをサーバに送る
socket->emit("join", send_data);
}
while(true) {
// イベントキューが空の場合、キューが補充されるまで待つ
std::unique_lock<std::mutex> lock(sio_mutex);
while (sio_queue.empty()) {
sio_cond.wait(lock);
}
// イベントキューから登録されたデータを取り出す
sio::message::ptr recv_data(sio_queue.front());
std::stringstream output;
char buf[1024];
FILE* fp = nullptr;
// objectのcommandメンバの値を取得する
std::string command = recv_data->get_map().at("command")->get_string();
std::cout << "run:" << command << std::endl;
// commandを実行し、実行結果を文字列として取得する
if ((fp = popen(command.c_str(), "r")) != nullptr) {
while (!feof(fp)) {
size_t len = fread(buf, 1, sizeof(buf), fp);
output << std::string(buf, len);
}
} else {
// エラーを検出した場合はエラーメッセージを取得する
output << strerror(errno);
}
pclose(fp);
sio::message::ptr send_data(sio::object_message::create());
std::map<std::string, sio::message::ptr>& map = send_data->get_map();
// コマンドの実行結果をobjectのoutputに設定する
map.insert(std::make_pair("output", sio::string_message::create(output.str())));
// sio::messageをサーバに送る
socket->emit("reply", send_data);
// 処理が終わったイベントをキューから取り除く
sio_queue.pop();
}
}
void *main_bluetooth(void *arg) {
int i, err, sock, dev_id = -1;
int num_rsp = 0, max_rsp = 5, flags = 0, length = 4; /* [1.28 *<length>]seconds [1.28*4 = 5.12] seconds */
char addr[19] = {0};
char cmd[100], cmd1[50];
char name[248] = {0}, bt_mac[19] = "00:00:00:00:00:00";
uuid_t uuid = {0};
int application_id = (int) *(int *) arg;
char uuid_str[50];
FILE *fd = NULL;
if (application_id == 2) {
printf("\nOpen application: Android Locomate Messaging\n");
strcpy(uuid_str, "66841278-c3d1-11df-ab31-001de000a901");
}
else if (application_id == 3) {
printf("\nOpen application: Spat Andriod Application\n");
strcpy(uuid_str, "66841278-c3d1-11df-ab31-001de000a903");
}
else if (application_id == 4) {
printf("\nOpen application: Bluetooth CAN application\n");
strcpy(uuid_str, "00001101-0000-1000-8000-00805F9B34FB");
fd = popen("cat /var/can.conf | grep BTCAN_MAC= | cut -d '=' -f 2", "r");
if (fd != NULL) {
fscanf(fd, "%s", bt_mac);
pclose(fd);
printf("Mac from conf file: %s\n", bt_mac);
}
}
else {
printf("\nOpen application: Locomate Safety Application\n");
strcpy(uuid_str, "66841278-c3d1-11df-ab31-001de000a902");
}
uint32_t range = 0x0000ffff;
sdp_list_t *response_list = NULL, *search_list, *attrid_list;
int status;
int responses;
int retries = 0;
struct sockaddr_rc loc_addr = {0};
signal(SIGINT, (void *) sig_int);
/* find the bluetooth device is available or not */
sprintf(cmd, "/usr/local/bin/hciconfig hci0 up");
system(cmd);
for (retries = 0; retries < 5; retries++) {
dev_id = hci_get_route(NULL);
if (dev_id < 0) {
perror("No Bluetooth Adapter Available\n");
sprintf(cmd, "/usr/local/bin/hciconfig hci0 down");
system(cmd);
sprintf(cmd1, "/usr/local/bin/hciconfig hci0 up");
system(cmd1);
printf("\nretry getting adapter : %d\n", retries);
}
else
break;
}
if (retries == 5) {
Btooth_forward = -1;
return NULL;
}
for (retries = 0; retries < 5; retries++) { //check for the socket
sock = hci_open_dev(dev_id);
if (sock < 0) {
perror("HCI device open failed");
retries++;
printf("\nretries sock : %d\n", retries);
}
else
break;
}
if (retries == 5) {
Btooth_forward = -2;
return NULL;
}
for (retries = 0; retries < 5; retries++) { //check uuid is correct or not
if (!str2uuid(uuid_str, &uuid)) {
perror("Invalid UUID");
retries++;
printf("\nretries str2 uuid : %d\n", retries);
}
else
break;
}
if (retries == 5) {
Btooth_forward = -3;
return NULL;
}
//printf("\nBluetooth Adapter Found \n");
info = (inquiry_info *) malloc(MAX_RSP * sizeof(inquiry_info));
while (1) { // loop to check and establish connection with other device
while (connection_established == FALSE) {
bzero(info, (MAX_RSP * sizeof(inquiry_info)));
num_rsp = hci_inquiry(dev_id, length, max_rsp, NULL, &info,
flags); // inquire for how many devices are available
if (num_rsp < 0) {
perror("Inquiry failed");
sched_yield();
sleep(1);
continue;
}
printf("Inquiry devices found : %d\n", num_rsp);
loco_channel = -1;
for (i = 0; i < num_rsp; i++) {
sdp_session_t *session;
ba2str(&(info + i)->bdaddr, addr);
printf("\nFound Mac: %s ", addr);
if (application_id == 4 && strcmp("00:00:00:00:00:00", bt_mac)) // check for appid and mac_id
if (strcasecmp(addr, bt_mac))
continue;
memset(name, 0, sizeof(name));
if (hci_read_remote_name(sock, &(info + i)->bdaddr, sizeof(name), name, 8000) < 0) //get devices by name
strcpy(name, "[unknown]");
printf("Found : %s name : [[ %s ]]\n", addr, name);
// connect to the SDP server running on the remote machine
session = NULL;
retries = 0;
while (!session) {
session = sdp_connect(BDADDR_ANY, &(info + i)->bdaddr, 0);
if (session) break;
if (errno != 0) {
fprintf(stderr, "sdp_connect failed error no %d : %s \n", errno, strerror(errno));
}
if ((retries < 2) && ((errno == EALREADY))) {
retries++;
fprintf(stderr, "Retry sdp_connect %d\t", retries);
sched_yield();
usleep(300000);//300 ms
continue; //continue till 3 times
}
break;
} /* while(!session) */
if (session == NULL) {
if (i < (num_rsp - 1))
printf("Trying next device -> %d\n", i + 2);
continue;
}
search_list = NULL;
attrid_list = NULL;
response_list = NULL;
search_list = sdp_list_append(NULL, &uuid); //append list of uuids
attrid_list = sdp_list_append(NULL, &range); // append list of attributes
err = 0;
err = sdp_service_search_attr_req(session, search_list, SDP_ATTR_REQ_RANGE, attrid_list,
&response_list); //search for attributes from list
sdp_list_t *r = response_list;
responses = 0;
// go through each of the service records
for (; r; r = r->next) {
responses++;
sdp_record_t *rec = (sdp_record_t *) r->data;
sdp_list_t *proto_list;
// get a list of the protocol sequences
if (sdp_get_access_protos(rec, &proto_list) == 0) {
sdp_list_t *p = proto_list;
// go through each protocol sequence
for (; p; p = p->next) {
sdp_list_t *pds = (sdp_list_t *) p->data;
// go through each protocol list of the protocol sequence
for (; pds; pds = pds->next) {
// check the protocol attributes
sdp_data_t *d = (sdp_data_t *) pds->data;
int proto = 0;
for (; d; d = d->next) {
switch (d->dtd) {
case SDP_UUID16:
case SDP_UUID32:
case SDP_UUID128:
proto = sdp_uuid_to_proto(&d->val.uuid);
break;
case SDP_UINT8:
if (proto == RFCOMM_UUID) {
printf("rfcomm channel: %d\n", d->val.int8);
loco_channel = d->val.int8;
}
break;
} /* switch(t->dtd) */
} /* for( ; d; d = d->next) */
} /* for( ; pds ; pds = pds->next) */
sdp_list_free((sdp_list_t *) p->data, 0);
} /* for( ; p; p = p->next) */
sdp_list_free(proto_list, 0);
} /* if(sdp_get_access_protos(rec, &proto_list)) */
sdp_record_free(rec);
if (loco_channel > 0) {
break;
}
} /* for (; r; r = r->next) */
sdp_list_free(response_list, 0);
sdp_list_free(search_list, 0);
sdp_list_free(attrid_list, 0);
printf("No of services= %d on device %d \n", responses, i + 1);
if (loco_channel > 0) {
// printf("Found Locomate Safety Application on device: name [%s], sending message now\n",name);
btooth_socket = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
loc_addr.rc_family = AF_BLUETOOTH;
loc_addr.rc_channel = loco_channel;
loc_addr.rc_bdaddr = (info + i)->bdaddr;
status = connect(btooth_socket, (struct sockaddr *) &loc_addr, sizeof(loc_addr));
if (status < 0) {
perror("\nuh oh: Btooth socket not created\n");
Btooth_forward = -5;
}
else {
sdp_close(session);
Btooth_forward = 1;
connection_established = TRUE;
break;
}
}
sdp_close(session);
} /* for (i = 0; i < num_rsp; i++) */
if (connection_established == FALSE) {
printf("Scanning again\n");
//sprintf(cmd, "/usr/local/bin/hciconfig hci0 down");
//system(cmd);
sprintf(cmd1, "/usr/local/bin/hciconfig hci0 up");
system(cmd1);
sched_yield();
sleep(1);
}
else {
printf("***Connection established***\n");
}
} /* while(connection_established == ...) */
sched_yield();
sleep(3); // wait for 3seconds, before next check
}
}
main(){
int sockfd;// to create socket
char message[MSGSIZE];
int nsockfd;
int clilen;
char message1[MAXSIZE+1];
int n;
int rec = 0;
struct sockaddr_in server_address, client_address;
if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{ perror("Server: socket() error\n");
exit(1); };
/* Get Server's IP address */
FILE *file;
char returnData[64];
char *token;
char a[1000];
file = popen("/sbin/ifconfig eth0", "r");
while (fgets(returnData, 64, file) != NULL)
{strcat(a, returnData);}
token = strtok(a, " ");
token = strtok(NULL, " ");
token = strtok(NULL, " ");
token = strtok(NULL, " ");
token = strtok(NULL, " ");
token = strtok(NULL, " ");
token = strtok(NULL, " ");
token = strtok(NULL, " addr:");
/* print the IP address token */
printf("Server IP address: %s\n", token);
bzero((char *) &server_address, sizeof(server_address));
server_address.sin_family = AF_INET;
server_address.sin_addr.s_addr = inet_addr(token);
server_address.sin_port = htons(SERV_TCP_PORT);
pclose(file);
if(bind(sockfd, (struct sockaddr *) &server_address, sizeof(server_address)) < 0)
perror("Server: bind() error\n");
printf("\nConnection....... .......... [bind]\n");
char *buf;
buf=(char *)malloc(10*sizeof(char));
buf=getlogin();
char path[30];
strcpy(path, "/home/");
strcat(path, buf);
strcat(path, "/FILE_OF_SERVER");
struct stat s;
if(stat(path, &s) == -1){
mkdir(path, 0700); }
listen(sockfd, 5);
int p[2];
if(pipe(p) == -1)
{
perror("Fail to create pipe");
exit(1);
}
for(;;)
{
clilen = sizeof(client_address);
nsockfd = accept(sockfd, (struct sockaddr *)&client_address, &clilen);
char *clientaddress = inet_ntoa(client_address.sin_addr);
char *individual_address;
write(p[1], &clientaddress, sizeof(clientaddress));
if(fork() == 0){
close(sockfd);
strcpy(message1,"** Hello, welcome to the server. ** \n\nPress\n1.Send File\t2.Download File\n3.Create Directory\t4.Delete Directory(include sub directory)\n[type /q to quit] : ");
send(nsockfd, message1, MAXSIZE, 0);
if(nsockfd > 0)
read(p[0],&individual_address,sizeof(individual_address));
printf("\nClient %s connected now.\n", individual_address);
do { n=recv(nsockfd, message, MSGSIZE, 0);
if(!strcmp(message, "1"))
{
bzero( message, sizeof(message));
strcat(message,"[List of files in Server Directory]\nPlease choose a file from above the list to download:\n\n");
DIR *dir;
struct dirent *ent;
char directoryName[30];
strcpy(directoryName, "/home/");
strcat(directoryName, buf);
strcat(directoryName, "/FILE_OF_SERVER/");
if ((dir = opendir (directoryName)) != NULL) {
while ((ent = readdir (dir)) != NULL) {
strcat(message, ent->d_name);
strcat(message, "\n");
}
closedir (dir);
send(nsockfd, message, MAXSIZE, 0);
}
else { perror ("Directory not exist.");
return EXIT_FAILURE;
}
bool exist = true;
do{ bzero( message, sizeof(message));
recv(nsockfd, message, MAXSIZE, 0);
char filename[30];
strcpy(filename, "/home/");
strcat(filename, buf);
strcat(filename, "/FILE_OF_SERVER/");
strcat(filename, message);
FILE *file = fopen(filename, "r");
if(file==NULL)
{
strcpy(message," NO such file in server.Please key in the correct filename with extension.");
send(nsockfd, message, MAXSIZE, 0);
exist = false;
}
if(exist == true )
{
bzero( message, sizeof(message));
int nread = fread(message,1,256,file);
send(nsockfd, message, nread, 0);
}
bzero( message, sizeof(message));
strcpy(message,"Sucessfully Downloaded. [/q to quit]");
}while(exist == false);}
if(!strcmp(message, "2"))
{ bzero( message, sizeof(message));
recv(nsockfd, message, MAXSIZE, 0);
char filename[30];
strcpy(filename, "/home/");
strcat(filename, buf);
strcat(filename, "/FILE_OF_SERVER/");
strcat(filename, message);
FILE *file;
file = fopen(filename, "ab");
bzero( message, sizeof(message));
rec = recv(nsockfd, message, MAXSIZE, 0);
fwrite(message,1,rec,file);
fclose(file);
bzero( message, sizeof(message));
strcat(message,"Congratulation you have sent the file you want. [/q to quit]");
}
if(!strcmp(message, "3"))
{
bzero( message, sizeof(message));
strcat(message,"Congratulation you have maked the directory. [/q to quit]");
}
if(!strcmp(message, "4"))
{
bzero( message, sizeof(message));
strcat(message,"Congratulation you have deleted directory. [/q to quit]");
}
if(n==0)
{
close(nsockfd);
break;
}
message[n]=0;
send(nsockfd, message, MAXSIZE, 0);
}while(strcmp(message1, "/q"));
printf("\nClient %s disconnected now.\n", individual_address);
exit(0);
}
close(nsockfd);
}
return 0;
}
void
rad2mgf( /* convert a Radiance file to MGF */
char *inp
)
{
char buf[512];
char mod[128], typ[32], id[128], alias[128];
FUNARGS fa;
register FILE *fp;
register int c;
if (inp == NULL) {
inp = "standard input";
fp = stdin;
} else if (inp[0] == '!') {
if ((fp = popen(inp+1, "r")) == NULL) {
fputs(inp, stderr);
fputs(": cannot execute\n", stderr);
exit(1);
}
} else if ((fp = fopen(inp, "r")) == NULL) {
fputs(inp, stderr);
fputs(": cannot open\n", stderr);
exit(1);
}
printf("# Begin conversion from: %s\n", inp);
while ((c = getc(fp)) != EOF)
switch (c) {
case ' ': /* white space */
case '\t':
case '\n':
case '\r':
case '\f':
break;
case '#': /* comment */
if (fgets(buf, sizeof(buf), fp) != NULL)
printf("# %s", buf);
break;
case '!': /* inline command */
ungetc(c, fp);
fgetline(buf, sizeof(buf), fp);
rad2mgf(buf);
break;
default: /* Radiance primitive */
ungetc(c, fp);
if (fgetword(mod, sizeof(mod), fp) == NULL ||
fgetword(typ, sizeof(typ), fp) == NULL ||
fgetword(id, sizeof(id), fp) == NULL) {
fputs(inp, stderr);
fputs(": unexpected EOF\n", stderr);
exit(1);
}
unspace(mod);
unspace(id);
if (!strcmp(typ, "alias")) {
strcpy(alias, "EOF");
fgetword(alias, sizeof(alias), fp);
unspace(alias);
newmat(id, alias);
} else {
if (!readfargs(&fa, fp)) {
fprintf(stderr,
"%s: bad argument syntax for %s \"%s\"\n",
inp, typ, id);
exit(1);
}
cvtprim(inp, mod, typ, id, &fa);
freefargs(&fa);
}
break;
}
printf("# End conversion from: %s\n", inp);
if (inp[0] == '!')
pclose(fp);
else
fclose(fp);
}
log::log::~log(){
if(fp)
fclose(fp);
if(tp)
pclose(tp);
}
bool find_sql_updates()
{
printf("+ finding new sql updates on HEAD\n");
// add all updates from HEAD
snprintf(cmd, MAX_CMD, "git show HEAD:%s", sql_update_dir);
if ((cmd_pipe = popen(cmd, "r")) == NULL)
return false;
// skip first two lines
if (!fgets(buffer, MAX_BUF, cmd_pipe)) { pclose(cmd_pipe); return false; }
if (!fgets(buffer, MAX_BUF, cmd_pipe)) { pclose(cmd_pipe); return false; }
sql_update_info info;
while (fgets(buffer, MAX_BUF, cmd_pipe))
{
buffer[strlen(buffer) - 1] = '\0';
if (!get_sql_update_info(buffer, info)) continue;
if (info.db_idx == NUM_DATABASES)
{
if (info.rev > 0) printf("WARNING: incorrect database name for sql update %s\n", buffer);
continue;
}
new_sql_updates.insert(buffer);
}
pclose(cmd_pipe);
// Add last milestone's file information
last_sql_rev[0] = 11785;
last_sql_nr[0] = 2;
sscanf("11785_02_characters_instance", "%s", last_sql_update[0]);
last_sql_rev[2] = 10008;
last_sql_nr[2] = 1;
sscanf("10008_01_realmd_realmd_db_version", "%s", last_sql_update[2]);
// remove updates from the last commit also found on origin
snprintf(cmd, MAX_CMD, "git show %s:%s", origin_hash, sql_update_dir);
if ((cmd_pipe = popen(cmd, "r")) == NULL)
return false;
// skip first two lines
if (!fgets(buffer, MAX_BUF, cmd_pipe)) { pclose(cmd_pipe); return false; }
if (!fgets(buffer, MAX_BUF, cmd_pipe)) { pclose(cmd_pipe); return false; }
while (fgets(buffer, MAX_BUF, cmd_pipe))
{
buffer[strlen(buffer) - 1] = '\0';
if (!get_sql_update_info(buffer, info)) continue;
// find the old update with the highest rev for each database
// (will be the required version for the new update)
std::set<std::string>::iterator itr = new_sql_updates.find(buffer);
if (itr != new_sql_updates.end())
{
if (info.rev > 0 && (info.rev > last_sql_rev[info.db_idx] ||
(info.rev == last_sql_rev[info.db_idx] && info.nr > last_sql_nr[info.db_idx])))
{
last_sql_rev[info.db_idx] = info.rev;
last_sql_nr[info.db_idx] = info.nr;
if (db_sql_rev_parent[info.db_idx])
snprintf(last_sql_update[info.db_idx], MAX_PATH, "%s_%0*d_%s%s%s", info.parentRev, 2, info.nr, info.db, info.has_table ? "_" : "", info.table);
else
sscanf(buffer, "%[^.]", last_sql_update[info.db_idx]);
}
new_sql_updates.erase(itr);
}
}
pclose(cmd_pipe);
if (!new_sql_updates.empty())
{
for (std::set<std::string>::iterator itr = new_sql_updates.begin(); itr != new_sql_updates.end(); ++itr)
printf("%s\n", itr->c_str());
}
else
printf("WARNING: no new sql updates found.\n");
return true;
}
/* Integrate the RS spectra with the detector response */
double rs_det( double *ex, int *nrs, float *emin, float *de )
{
int i,icgs,dlength,j,loc,numt,spec_bins,k,locl,loch,abs_n;
double *spec,lambda_cgs,lambda_det,lambda_s,integral,val,cnts2cgs;
float *elo,*ehi,*area,spec_emin,spec_de,spec_scale,bandmin,
bandmax,emid,te,*spec_e,abs_e[260],abs_sigma[260],y2abs[260],
*absorption,sigma,NH;
char dirname[300],infile1[300],infile2[300],command[300];
char trash[200],junk[200];
FILE *inp,*pip;
void spline(),splint();
/* H column density [10^20 cm^-2] */
NH = 0.0;
icgs = 0; /* [icgs = 1 (CGS: erg s^-1 cm^-2], 0 [cnts s^-1] */
*spec = *ex;
spec_bins = *nrs;
spec_emin = *emin;
spec_de = *de;
strcpy(dirname,"/dworkin/home/daisuke/Raymond/EffArea/");
strcat(infile1,dirname);
strcat(infile2,dirname);
strcat(infile1,"chandra_acis-s-bi_0.3-7.0keV.eff");
strcat(infile2,"cross_sections.dat");
/* calculate length of detector area file */
sprintf(command,"wc %s",infile1);
pip=popen(command,"r");
fscanf(pip,"%d",&dlength);
dlength--;
pclose(pip);
elo=(float *)calloc(dlength,sizeof(float));
ehi=(float *)calloc(dlength,sizeof(float));
area=(float *)calloc(dlength,sizeof(float));
/* read in detector effective area */
inp=fopen(infile1,"r");
fgets(trash,200,inp);
sscanf(trash,"%s %f %f",&junk,&bandmin,&bandmax);
printf("# %s: Band is %5.2f:%5.2f with %d energy channels\n",
infile1,bandmin,bandmax,dlength);
for (i=0;i<dlength;i++)
fscanf(inp,"%f %f %f",elo+i,ehi+i,area+i);
fclose(inp);
/* read in the galactic absorption cross sections */
inp=fopen(infile2,"r");
abs_n=0;while(fgets(trash,200,inp)!=NULL) {
if (strncmp(trash,"#",1)) {
sscanf(trash,"%f %f",abs_e+abs_n,abs_sigma+abs_n);
abs_n++;
}
}
fclose(inp);
/* spline this for future use */
spline(abs_e-1,abs_sigma-1,abs_n,0.0,0.0,y2abs-1);
/* cycle through rs-spectra, calculating lambdas */
/* exit if spectra don't extend beyond range of detector sensitivity */
if (bandmin<spec_emin || bandmax>spec_emin+spec_de*spec_bins) {
printf(" Detector energy range larger than R-S spectra range\n");
exit(0);
}
spec=(double *)calloc(spec_bins,sizeof(double));
spec_e=(float *)calloc(spec_bins,sizeof(float));
absorption=(float *)calloc(spec_bins,sizeof(float));
for (j=0;j<spec_bins;j++) {
spec_e[j]=spec_emin+(float)j*spec_de;
/* calculate the absorption cross section at this energy */
if (spec_e[j]<abs_e[0]) sigma=abs_sigma[0];
else {
if (spec_e[j]>abs_e[abs_n-1]) sigma=abs_sigma[abs_n-1];
else splint(abs_e-1,abs_sigma-1,y2abs-1,abs_n,spec_e[j],&sigma);
}
absorption[j]=exp(-1.0*sigma*NH);
/* RS spectrum is modified by the galactic absorption */
spec[j]*=absorption[j];
}
/* calculate lambda in detector units */
lambda_det=0.0;
for (j=0;j<dlength;j++) {
/* integrate over spectral emissivity from elo[] to ehi[] */
locl=(int)((elo[j]-spec_emin)/spec_de);
loch=(int)((ehi[j]-spec_emin)/spec_de);
/* detector bin lies within single R-S bin */
if (locl==loch) integral=area[j]*(ehi[j]-elo[j])*spec[locl];
else {/* detector bin extends over more than one R-S bin */
/* take care of the first partial bin */
integral=(spec_de-(elo[j]-spec_e[locl]))*spec[locl];
/* add all the enclosed bins */
for (k=locl+1;k<loch;k++) integral+=spec_de*spec[k];
/* take care of the last partial bin */
integral+=(ehi[j]-spec_e[loch])*spec[loch];
/* now scale by the area of this detector bin */
integral*=area[j];
}
/* convert from cgs to counts */
emid=0.5*(elo[j]+ehi[j]);
val=integral/(emid*KEV_2_ERGS);
lambda_det+=val;
}
/* now calculate theoretical lambda in cgs units */
loc=(bandmin-spec_emin)/spec_de;
/* initialize using value from first partial bin */
lambda_cgs=(spec_de-(bandmin-spec_e[loc]))*spec[loc];
/* add contribution from all the full bins */
for (j=loc+1;j<spec_bins;j++) {
if (bandmax>spec_e[j+1])
lambda_cgs+=spec_de*spec[j];
else break;
}
/* add contribution from last partial bin */
lambda_cgs+=(bandmax-spec_e[j])*spec[j];
/* calculate conversion from observed count rate to cgs flux */
if (lambda_det>0.0) cnts2cgs=lambda_cgs/lambda_det;
else cnts2cgs=0.0;
if (icgs ==1) return(lambda_cgs);
if (icgs ==0) return(lambda_det);
}
// In this method, we will execute the nslookup command and return back
// four pieces of information in a map ash shown below.
// "Name Server Name" => "Name of the name server"
// "Name Server Address" => "IP address of the name server"
// "Client Machine Name" => "Fully qualified name of the client machine"
// "Client Machine Address" => "IP address of the client machine"
unordered_map<string, string> NameServerLookup::getNSLookupResults(string const & nodeName) {
FILE *fpipe;
string nsLookupCommand = (string)"nslookup " + nodeName;
char line[256];
unordered_map <string, string> result;
string replyLineKey1 = "Name Server Name";
string replyLineKey2 = "Name Server Address";
string replyLineKey3 = "Client Machine Name";
string replyLineKey4 = "Client Machine Address";
if (!(fpipe = (FILE*)popen(nsLookupCommand.c_str(),"r"))) {
// If fpipe is NULL
// Mark the errors in the map.
result[replyLineKey1] = "Pipe failure";
result[replyLineKey2] = "Pipe failure";
result[replyLineKey3] = "Pipe failure";
result[replyLineKey4] = "Pipe failure";
return (result);
} // End of if (!(fpipe = (FILE*)popen(command,"r")))
int32_t cnt = 1;
while (fgets( line, sizeof line, fpipe)) {
// nslookup result looks like this.
// Server: 10.4.24.230
// Address: 10.4.24.230#53
//
// Name: a0217b10e1.hny.distillery.ibm.com
// Address: 10.4.40.210
//
// Let us parse only the last token in every line as that is what we want.
//
std::string resultStr = string(line);
// construct a stream from the string
std::stringstream strStream(resultStr);
// use stream iterators to copy the stream to the vector as whitespace separated strings
std::istream_iterator<std::string> it(strStream);
std::istream_iterator<std::string> end;
std::vector<std::string> results(it, end);
// cout << "Vector size = " << results.size() << endl;
// Let us now get the last token in the vector.
std::string lastToken = "";
if (results.size() > 0) {
lastToken = results.at(results.size() - 1);
} // End of if (results.size() > 0)
switch (cnt++) {
case 1:
result[replyLineKey1] = lastToken;
break;
case 2:
result[replyLineKey2] = lastToken;
break;
case 3:
// This must be an empty line in the nslookup result.
break;
case 4:
result[replyLineKey3] = lastToken;
break;
case 5:
result[replyLineKey4] = lastToken;
break;
} // End of switch (cnt++)
// If we already processed 5 lines, we have
// collected everything we need from the result.
if (cnt > 5) {
// Break from the while loop.
break;
} // End of if (cnt > 5)
// printf("%s", line);
} // End of while (fgets( line, sizeof line, fpipe))
pclose (fpipe);
return (result);
} // End of method getNSLookupResults(string & nodeName).
/*
* Using the current debconf settings for a mirror, figure out which suite
* to use from the mirror and set mirror/suite.
*
* This is accomplished by downloading the Release file from the mirror.
* Suite selection tries each suite in turn, and stops at the first one that
* seems usable.
*
* If no Release file is found, returns false. That probably means the
* mirror is broken or unreachable.
*/
int find_suite (void) {
char *command;
FILE *f = NULL;
char *hostname, *directory;
int nbr_suites = sizeof(suites)/SUITE_LENGTH;
int i;
int ret = 0;
char buf[SUITE_LENGTH];
if (show_progress) {
debconf_progress_start(debconf, 0, 1,
DEBCONF_BASE "checking_title");
debconf_progress_info(debconf,
DEBCONF_BASE "checking_download");
}
hostname = add_protocol("hostname");
debconf_get(debconf, hostname);
free(hostname);
hostname = strdup(debconf->value);
directory = add_protocol("directory");
debconf_get(debconf, directory);
free(directory);
directory = strdup(debconf->value);
/* Try each suite in turn until one is found that works. */
for (i=0; i <= nbr_suites && ! ret; i++) {
char *suite;
if (i == 0) {
/* First check for a preseeded suite. */
debconf_get(debconf, DEBCONF_BASE "suite");
if (strlen(debconf->value) > 0) {
suite = strdup(debconf->value);
}
else {
/* Read this file to find the default suite
* to use. */
f = fopen("/etc/default-release", "r");
if (f != NULL) {
if (fgets(buf, SUITE_LENGTH - 1, f)) {
if (buf[strlen(buf) - 1] == '\n')
buf[strlen(buf) - 1] = '\0';
suite = strdup(buf);
fclose(f);
}
else {
fclose(f);
continue;
}
}
else {
continue;
}
}
}
else {
suite = strdup(suites[i - 1]);
}
asprintf(&command, "wget -q %s://%s%s/dists/%s/Release -O - | grep ^Suite: | cut -d' ' -f 2",
protocol, hostname, directory, suite);
di_log(DI_LOG_LEVEL_DEBUG, "command: %s", command);
f = popen(command, "r");
free(command);
if (f != NULL) {
if (fgets(buf, SUITE_LENGTH - 1, f)) {
if (buf[strlen(buf) - 1] == '\n')
buf[strlen(buf) - 1] = '\0';
debconf_set(debconf, DEBCONF_BASE "suite", buf);
ret = 1;
}
}
pclose(f);
free(suite);
}
free(hostname);
free(directory);
if (show_progress) {
debconf_progress_step(debconf, 1);
debconf_progress_stop(debconf);
}
return ret;
}
string * FASTA_Parser::getSequence() {
string line;
if (sequence != 0) {
cerr << "error: sequence has already been read via getSequence()" << endl;
exit(1);
}
sequence = new string();
if (expected_sequence_length > 0) {
sequence->reserve(expected_sequence_length);
}
//cerr << "getSequence" << endl;
//cout <<"line: "<< line << endl;
while (true) {
std::getline(*rna_stream, line);
if (rna_stream->fail()) {
break;
}
//cout << "fail: " << rna_stream->fail() << endl;
//cerr << "y:" << line << endl;
if (line.length() == 0) {
continue;
}
if (line[0] == '#' ) {
continue;
}
if (line[0] == '>' ) {
//this->description_line = getFASTADescription(line);
if (getOnlyIdentfier) {
this->description_line = getFASTADescription(line);
} else {
this->description_line = line;
}
have_read_descr = false;
sequence->reserve(sequence->length());
return sequence;
} else {
int lastpos = line.length()-1;
if (line[lastpos] == '\n') {
line.erase(lastpos); // remove trailing newline
}
//sequence->append("@");
//cout << "append" << endl;
sequence->append(line);
}
}
//file_closed = true;
if (fp != 0) {
pclose(fp);
fp = 0;
}
sequence->reserve(sequence->length());
return sequence;
}
int pg_getfname ( char *subset, char *fname, char *descr )
/************************************************************************
* pg_getfname *
* *
* This function retrieves the name of a plot file from the plot node *
* based upon the product index table. *
* *
* int pg_getfname ( subset, fname, descr ) *
* *
* Input parameters: *
* *subset char Subset to retrieve *
* *
* Output parameters: *
* *fname char Name of file for this subset *
* *descr char ASCII descriptor of that subset *
* pg_getfname int Return value: *
* -1 Failure *
* 0 Success *
** *
* Log: *
* E. Wehner/EAi 5/96 Created *
* T. Piper/GSC 10/98 Prolog update *
***********************************************************************/
{
FILE *pfp;
char cmd[120];
char cmd_in[120];
char file_name[20];
char *s;
int i;
sprintf(cmd, "rsh %s@%s %s %s | cut -c7-",
PLOT_USERNAME, PLOT_NODE, PLOT_INDEXCMD,
subset);
if ( (pfp = popen(cmd, "r")) != 0)
{
fgets(cmd_in, sizeof(cmd_in), pfp);
pclose (pfp);
/* get the name of the file by looking at the first 14 bytes */
strncpy(file_name, cmd_in, 16);
file_name[16] = '\0';
s = &file_name[0];
/* remove the left padding from the filenam */
while ( (*s <= ' ') && (s < &file_name[19]) ) s++;
if ( ( s[0] < ' ') || (s[0] > 'z') )
{
return -1;
}
sprintf(fname, "%s/%s", getenv("FAX_TEMP"), s);
/* remove cr if it is there */
for (i=0;i<(int)strlen(fname); i++)
if (fname[i] <= ' ') fname[i] = '\0';
strncpy(descr, &cmd_in[15], 100);
}
else
return -1;
return 0;
}
//client connection
void respond(int n)
{
char *result = (char *) malloc(sizeof(char) * 10000);// result return to client
char *pure_path = (char *) malloc(sizeof(char) * 10000);// get path
char *buf = (char *) malloc(sizeof(char) * 10000);
char *cmd1 = (char *) malloc(sizeof(char) * 1000);// command for 'ls -l'
char *cmd2 = (char *) malloc(sizeof(char) * 1000);// command for 'cat '
char *param = "/?param=";
char *pos;
char c;
int index;
FILE *file;// use pipeline
struct stat s;// use to know if the path is a file or a directory
char mesg[99999], *reqline[3], data_to_send[BYTES], path[99999], html[999];
int rcvd, fd, bytes_read;
memset( (void*)mesg, (int)'\0', 99999 );
//rcvd=recv(clients[n], mesg, 99999, 0);
rcvd=read(clients[n], mesg, 99999);
if (rcvd<0) // receive error
fprintf(stderr,("recv() error\n"));
else if (rcvd==0) // receive socket closed
fprintf(stderr,"Client disconnected upexpectedly.\n");
else // message received
{
printf("%s", mesg);
reqline[0] = strtok (mesg, " \t\n");
if ( strncmp(reqline[0], "GET\0", 4)==0 )
{
reqline[1] = strtok (NULL, " \t");
reqline[2] = strtok (NULL, " \t\n");
if ( strncmp( reqline[2], "HTTP/1.0", 8)!=0 && strncmp( reqline[2], "HTTP/1.1", 8)!=0 )
{
write(clients[n], "HTTP/1.0 400 Bad Request\n", 25);
}
else
{
pos = strstr(reqline[1], param) + 8; //get 1st position when meet '/?param=', +8 means pass through until the real path. Ex: /home/ubuntu/syspro
index = 0;
// get path(not include '/?param='), terminate when meet ' '
while ((c = *pos) != NULL) {
pure_path[index++] = c;
pos++;
}
pure_path[index] = '\n';
if (stat(pure_path, &s) == 0) {
if (s.st_mode & S_IFDIR) {
printf("path is a directory\n");
strcat(cmd1, "ls -l ");//initialize comd1 as 'ls -l'
strcat(cmd1, pure_path);//now, it becomes, for example, "ls -l /home/ubuntu/"
file = popen(cmd1, "r");//execute command and open a pipeline
while (fgets(buf, 10000, file))
strcat(result, buf);//read and add content of the pipeline into result
pclose(file);
printf("%s\n", result);
} else if (s.st_mode & S_IFREG) {
printf("path is a file\n");
strcat(cmd2, "cat ");//initialize comd2 as 'cat '
strcat(cmd2, pure_path);//now, it becomes, for example, "cat /home/ubuntu/syspro/f13.c"
file = popen(cmd2, "r");//excute command and open a pipeline
while (fgets(buf, 10000, file))
strcat(result, buf);//read and add content of the pipeline into result
pclose(file);
printf("%s\n", result);
} else {
printf("something else!\n");
}
} else {
strcat(result, "Error!\n");
printf("wtf! Error!!\n");
}
write(clients[n], result,strlen(result));
}
}
}
//Closing SOCKET
shutdown (clients[n], SHUT_RDWR); //All further send and recieve operations are DISABLED...
close(clients[n]);
clients[n]=-1;
exit(0);
}
int exec_str(struct sip_msg *msg, str* cmd, char *param, int param_len) {
struct action act;
int cmd_len;
FILE *pipe;
char *cmd_line;
int ret;
char uri_line[MAX_URI_SIZE+1];
int uri_cnt;
int uri_len;
int exit_status;
/* pessimist: assume error by default */
ret=-1;
cmd_len=cmd->len+param_len+2;
cmd_line=pkg_malloc(cmd_len);
if (cmd_line==0) {
ret=ser_error=E_OUT_OF_MEM;
LOG(L_ERR, "ERROR: exec_str: no mem for command\n");
goto error00;
}
/* 'command parameter \0' */
memcpy(cmd_line, cmd->s, cmd->len); cmd_line[cmd->len]=' ';
memcpy(cmd_line+cmd->len+1, param, param_len);cmd_line[cmd->len+param_len+1]=0;
pipe=popen( cmd_line, "r" );
if (pipe==NULL) {
LOG(L_ERR, "ERROR: exec_str: cannot open pipe: %s\n",
cmd_line);
ser_error=E_EXEC;
goto error01;
}
/* read now line by line */
uri_cnt=0;
while( fgets(uri_line, MAX_URI_SIZE, pipe)!=NULL){
uri_len=strlen(uri_line);
/* trim from right */
while(uri_len && (uri_line[uri_len-1]=='\r'
|| uri_line[uri_len-1]=='\n'
|| uri_line[uri_len-1]=='\t'
|| uri_line[uri_len-1]==' ' )) {
DBG("exec_str: rtrim\n");
uri_len--;
}
/* skip empty line */
if (uri_len==0) continue;
/* ZT */
uri_line[uri_len]=0;
if (uri_cnt==0) {
memset(&act, 0, sizeof(act));
act.type = SET_URI_T;
act.val[0].type = STRING_ST;
act.val[0].u.string = uri_line;
if (do_action(&act, msg)<0) {
LOG(L_ERR,"ERROR:exec_str : SET_URI_T action failed\n");
ser_error=E_OUT_OF_MEM;
goto error02;
}
} else {
if (append_branch(msg, uri_line, uri_len, 0, 0, Q_UNSPECIFIED, 0)==-1) {
LOG(L_ERR, "ERROR: exec_str: append_branch failed;"
" too many or too long URIs?\n");
goto error02;
}
}
uri_cnt++;
}
if (uri_cnt==0) {
LOG(L_ERR, "ERROR:exec_str: no uri from %s\n", cmd_line );
goto error02;
}
/* success */
ret=1;
error02:
if (ferror(pipe)) {
LOG(L_ERR, "ERROR: exec_str: error in pipe: %s\n",
strerror(errno));
ser_error=E_EXEC;
ret=-1;
}
exit_status=pclose(pipe);
if (WIFEXITED(exit_status)) { /* exited properly .... */
/* return false if script exited with non-zero status */
if (WEXITSTATUS(exit_status)!=0) ret=-1;
} else { /* exited erroneously */
LOG(L_ERR, "ERROR: exec_str: cmd %.*s failed. "
"exit_status=%d, errno=%d: %s\n",
cmd->len, ZSW(cmd->s), exit_status, errno, strerror(errno) );
ret=-1;
}
error01:
pkg_free(cmd_line);
error00:
return ret;
}
