static int do_rotate(LOGGER_HANDLE *log)
{
char namebuf[FN_REFLEN];
int result;
unsigned int i;
char *buf_old, *buf_new, *tmp;
if (log->rotations == 0)
return 0;
memcpy(namebuf, log->path, log->path_len);
buf_new= logname(log, namebuf, log->rotations);
buf_old= log->path;
for (i=log->rotations-1; i>0; i--)
{
logname(log, buf_old, i);
if (!access(buf_old, F_OK) &&
(result= my_rename(buf_old, buf_new, MYF(0))))
goto exit;
tmp= buf_old;
buf_old= buf_new;
buf_new= tmp;
}
if ((result= my_close(log->file, MYF(0))))
goto exit;
namebuf[log->path_len]= 0;
result= my_rename(namebuf, logname(log, log->path, 1), MYF(0));
log->file= my_open(namebuf, LOG_FLAGS, MYF(0));
exit:
errno= my_errno;
return log->file < 0 || result;
}
void
finduser(register struct packet *pkt)
{
register char *p;
char *user;
char groupid[6];
int none;
int ok_user;
extern char saveid[];
none = 1;
#if 0
user = logname();
#else
user = saveid;
#endif
sprintf(groupid,"%lu",(unsigned long)getgid());
while ((p = getline(pkt)) != NULL && *p != CTLCHAR) {
none = 0;
ok_user = 1;
repl(p,'\n','\0'); /* this is done for equal test below */
if(*p == '!') {
++p;
ok_user = 0;
}
if (!pkt->p_user)
if (equal(user,p) || equal(groupid,p))
pkt->p_user = ok_user;
*(strend(p)) = '\n'; /* repl \0 end of line w/ \n again */
}
if (none)
pkt->p_user = 1;
if (p == NULL || p[1] != EUSERNAM)
fmterr(pkt);
}
//-------------------------------------------------------------------------------------------------
Logger *Configuration::create_logger(const XmlElement *from, const Logtype ltype, const SessionID *sid) const
{
string name;
if (from && from->GetAttr(ltype == session_log ? "session_log" : "protocol_log", name))
{
const XmlElement *which(find_logger(name));
if (which)
{
string type;
if (which->GetAttr("type", type)
&& ((type % "session" && ltype == session_log) || (type % "protocol" && ltype == protocol_log)))
{
string logname("logname_not_set.log");
which->FindAttrRef("filename", logname);
trim(logname);
if (logname[0] == '|')
#ifndef HAVE_POPEN
throw f8Exception("popen not supported on your platform");
#endif
return new PipeLogger(logname, get_logflags(which));
RegMatch match;
if (_ipexp.SearchString(match, logname, 3) == 3)
{
f8String ip, port;
_ipexp.SubExpr(match, logname, ip, 0, 1);
_ipexp.SubExpr(match, logname, port, 0, 2);
BCLogger *bcl(new BCLogger(ip, get_value<unsigned>(port), get_logflags(which)));
if (*bcl)
return bcl;
}
get_logname(which, logname, sid); // only applies to file loggers
return new FileLogger(logname, get_logflags(which), get_logfile_rotation(which));
}
}
}
return 0;
}
//-------------------------------------------------------------------------------------------------
Logger *Configuration::create_logger(const XmlEntity *from, const Logtype ltype) const
{
string name;
if (from && from->GetAttr(ltype == session_log ? "session_log" : "protocol_log", name))
{
const XmlEntity *which(find_logger(name));
if (which)
{
string type;
if (which->GetAttr("type", type)
&& ((type % "session" && ltype == session_log) || (type % "protocol" && ltype == protocol_log)))
{
string logname("logname_not_set.log");
trim(get_logname(which, logname));
if (logname[0] == '|' || logname[0] == '!')
return new PipeLogger(logname, get_logflags(which));
RegMatch match;
if (_ipexp.SearchString(match, logname, 3) == 3)
{
f8String ip, port;
_ipexp.SubExpr(match, logname, ip, 0, 1);
_ipexp.SubExpr(match, logname, port, 0, 2);
BCLogger *bcl(new BCLogger(ip, GetValue<unsigned>(port), get_logflags(which)));
if (*bcl)
return bcl;
}
return new FileLogger(logname, get_logflags(which), get_logfile_rotation(which));
}
}
}
return 0;
}
void unpackLM(UINT8 *buf, long recno)
{
FILE *fp;
IDA10_LM lm;
static char *fid = "unpackLM";
if (!ida10UnpackLM(buf, &lm)) {
sprintf(Buffer, "%s: can't decode LM record no. %ld\n",
fid, recno
);
logmsg(Buffer);
return;
}
if ((fp = fopen(logname(lm.sname), "a")) == NULL) {
sprintf(Buffer, "%s: fopen: %s: %s",
fid, logname, strerror(errno)
);
logmsg(Buffer);
} else {
fprintf(fp, "%s", lm.text);
fclose(fp);
}
}
int main(int argc, char **argv)
{
if (argc<6) {
fprintf(stderr,"ERROR, not enough argument\n");
exit(1);
}
std::string filename(argv[1]);
int SERVICE_PORT =atoi(argv[2]);
std::string s_add(argv[3]);
int portno = atoi(argv[4]);
std::string logname(argv[5]);
char cCurrentPath[FILENAME_MAX];
if (!getcwd(cCurrentPath, sizeof(cCurrentPath)))
{
return errno;
}
std::string pathname(cCurrentPath);
filename = pathname + "/" + filename;
if (logname=="stdout") {
logfs = stdout;
}
else{
logname = pathname + "/" + logname;
logfs = fopen(logname.c_str(), "w");
}
FILE *ofs = fopen(filename.c_str(), "w");
//FILE *ofs = fopen("/Users/Rex/Desktop/cn_second/cn_second/o.txt", "w");
struct sockaddr_in myaddr; /* our address */
struct sockaddr_in remaddr; /* remote address */
socklen_t addrlen = sizeof(remaddr); /* length of addresses */
int recvlen; /* # bytes received */
int fd; /* our socket */
/* create a UDP socket */
if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
perror("cannot create socket\n");
return 0;
}
/* bind the socket to any valid IP address and a specific port */
memset((char *)&myaddr, 0, sizeof(myaddr));
myaddr.sin_family = AF_INET;
myaddr.sin_addr.s_addr = htonl(INADDR_ANY);
myaddr.sin_port = htons(SERVICE_PORT);
if (bind(fd, (struct sockaddr *)&myaddr, sizeof(myaddr)) < 0) {
perror("bind failed");
return 0;
}
/////intial ack related sender tcp//////
int n,sockfd;
struct sockaddr_in serv_addr;
struct hostent *server;
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0)
printf("ERROR opening socket");
server = gethostbyname(s_add.c_str());
if (server == NULL) {
fprintf(stderr,"ERROR, no such host\n");
exit(0);
}
bzero((char *) &serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
bcopy((char *)server->h_addr,
(char *)&serv_addr.sin_addr.s_addr,
server->h_length);
serv_addr.sin_port = htons(portno);
if (connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr)) < 0)
printf("ERROR connecting");
int ws;
char addtmp[256];
read(sockfd, &ws, sizeof(int));
read(sockfd, addtmp, 255);
write(sockfd,s_add.c_str() , s_add.size() );
//local = string(addtmp,strlen(addtmp));
local = "127.0.0.1";
//////////
std::vector<out_order_buffer_unit> out_order_buf;
for(int i = 0; i<ws; i ++){
byte *temp = new byte[BUFSIZE+20];
out_order_buffer_unit tmp(-1,temp);
out_order_buf.push_back(tmp);
}
/* now loop, receiving data and printing what we received */
//printf("waiting on port %d\n", SERVICE_PORT);
byte *tcp_packet = new byte[20+BUFSIZE];
short flag,checksum,trash_short;
short len = BUFSIZE;
int totalbyte = 0,countretrans=0;
int seq = 0,acknum = 0,rcv_base = 0,trash_int = 0,hehe;
while(1){
recvlen = recvfrom(fd, tcp_packet, 20+BUFSIZE, 0, (struct sockaddr *)&serv_addr, &addrlen);
len = parse_packet(tcp_packet, &seq, &acknum, &flag, &checksum);
writelog(time(0), s_add, local, seq*BUFSIZE, seq*BUFSIZE+1, flag, -1);
if (flag == END) {
break;
}
if (len==-1){
continue;
}
else{
if (seq==rcv_base) {
totalbyte += 20+len;
//string tmp = "len is "+std::to_string(len)+"\n";
//fwrite(tmp.c_str(), 1, tmp.size(), logfs);
//std::cout<<"len is "<<len<<"\n";
//std::cout<<"Write seq # "<<seq<<" with len = "<<len<<"\n";
fwrite(tcp_packet+20, 1, len, ofs);
//greedy check buffer
int target = seq+1;
rcv_base++;
for(int i = 0; i<ws; i++){
if (out_order_buf[i].first == target){
short len_t = parse_packet(out_order_buf[i].second, &hehe, &trash_int, &trash_short, &trash_short);
//tmp = "len_t is "+std::to_string(len_t)+"\n";
//fwrite(tmp.c_str(), 1, tmp.size(), logfs);
fwrite( (out_order_buf[i].second)+ 20, 1, len_t, ofs);
totalbyte += 20+len_t;
rcv_base++;
target++;
out_order_buf[i].first = -1;
}
}
acknum = seq+1;
flag = ACK;
make_packet(tcp_packet, &seq, &acknum, &flag, &checksum, ofs);
n = write(sockfd, tcp_packet, 20);
if (n < 0)
printf("ERROR writing to socket");
writelog(time(0), local, s_add, seq*BUFSIZE, seq*BUFSIZE+1, flag, -1);
}
else //out of order, buffer it
{
for(int i = 0; i<ws; i++){
if (out_order_buf[i].first == -1){
memcpy(out_order_buf[i].second, tcp_packet, 20+BUFSIZE);
out_order_buf[i].first = seq;
sort(out_order_buf.begin(),out_order_buf.end());
break;
}
}
acknum = seq + 1;
flag = ACK;
checksum = 0;
make_packet(tcp_packet, &seq, &acknum, &flag, &checksum, ofs);
n = write(sockfd, tcp_packet, 20);
if (n < 0)
printf("ERROR writing to socket");
writelog(time(0), local, s_add, seq*BUFSIZE, seq*BUFSIZE+1, flag, -1);
}
}
//printf("seq is %d\n",seq);
}
string summary = "Transmission was successful!\nTotal bytes sent is "+std::to_string(totalbyte)+
"\nNumber of sent segment is "+std::to_string(seq)+"\n";
fwrite(summary.c_str(), 1, summary.size(), logfs);
fclose(logfs);
fclose(ofs);
free(tcp_packet);
for(int i = 0; i<ws; i ++){
free(out_order_buf[i].second);
}
return 0;
}
void YamlConfigurable::logEffective(int verbosity) const {
LOG_INFO_NAMESTR(SDL_LOG_PREFIX_STR + logname(), "effective configuration for "
<< *this << "\n "
<< YamlConfigurableEffective(*this, verbosity));
logEffectiveOnce_.finishNonAtomic();
}
StringConsumer YamlConfigurable::log() const {
return Util::logWarning(logname());
}
int main(int argc, const char **argv)
{
#ifdef _WIN32
_setmode( _fileno( stdout ), _O_BINARY );
_setmode( _fileno( stdin ), _O_BINARY );
#endif
Owned<IProperties> globals = createProperties("dumpkey.ini", true);
for (int i = 1; i < argc; i++)
{
if (argv[i][0] == '-')
doOption(argv[i]);
else if (strchr(argv[i], '='))
globals->loadProp(argv[i]);
else
globals->setProp("keyfile", argv[i]);
}
try
{
StringBuffer logname("dumpkey.");
logname.append(GetCachedHostName()).append(".");
StringBuffer lf;
openLogFile(lf, logname.append("log").str());
Owned <IKeyIndex> index;
const char * keyName = globals->queryProp("keyfile");
if (keyName)
index.setown(createKeyIndex(keyName, 0, false, false));
else
usage();
Owned <IKeyCursor> cursor = index->getCursor(NULL);
size32_t key_size = index->keySize();
Owned<IFile> in = createIFile(keyName);
Owned<IFileIO> io = in->open(IFOread);
if (!io)
throw MakeStringException(999, "Failed to open file %s", keyName);
Owned<CKeyHdr> header = new CKeyHdr;
MemoryAttr block(sizeof(KeyHdr));
io->read(0, sizeof(KeyHdr), (void *)block.get());
header->load(*(KeyHdr*)block.get());
unsigned nodeSize = header->getNodeSize();
if (!optRaw)
{
printf("Key '%s'\nkeySize=%d NumParts=%x, Top=%d\n", keyName, key_size, index->numParts(), index->isTopLevelKey());
printf("File size = %"I64F"d, nodes = %"I64F"d\n", in->size(), in->size() / nodeSize - 1);
printf("rootoffset=%"I64F"d[%"I64F"d]\n", header->getRootFPos(), header->getRootFPos()/nodeSize);
}
char *buffer = (char*)alloca(key_size);
if (globals->hasProp("node"))
{
if (stricmp(globals->queryProp("node"), "all")==0)
{
}
else
{
int node = globals->getPropInt("node");
if (node != 0)
index->dumpNode(stdout, node * nodeSize, globals->getPropInt("recs", 0), optRaw);
}
}
else if (globals->hasProp("fpos"))
{
index->dumpNode(stdout, globals->getPropInt("fpos"), globals->getPropInt("recs", 0), optRaw);
}
else
{
bool backwards=false;
bool ok;
if (globals->hasProp("end"))
{
memset(buffer, 0, key_size);
strcpy(buffer, globals->queryProp("end"));
ok = cursor->ltEqual(buffer, buffer);
backwards = true;
}
else if (globals->hasProp("start"))
{
memset(buffer, 0, key_size);
strcpy(buffer, globals->queryProp("start"));
ok = cursor->gtEqual(buffer, buffer);
}
else
ok = cursor->first(buffer);
unsigned count = globals->getPropInt("recs", 1);
while (ok && count--)
{
offset_t pos = cursor->getFPos();
unsigned __int64 seq = cursor->getSequence();
size32_t size = cursor->getSize();
if (optRaw)
{
fwrite(buffer, 1, size, stdout);
}
else if (optHex)
{
for (unsigned i = 0; i < size; i++)
printf("%02x", ((unsigned char) buffer[i]) & 0xff);
printf(" :%"I64F"u:%012"I64F"x\n", seq, pos);
}
else
printf("%.*s :%"I64F"u:%012"I64F"x\n", size, buffer, seq, pos);
if (backwards)
ok = cursor->prev(buffer);
else
ok = cursor->next(buffer);
}
}
}
catch (IException *E)
{
StringBuffer msg;
E->errorMessage(msg);
E->Release();
fatal("%s", msg.str());
}
releaseAtoms();
ExitModuleObjects();
return 0;
}
