void command_rget(int sfd_client, struct packet* chp)
{
char temp[LENBUFFER];
clear_packet(chp);
chp->type = REQU;
chp->comid = RGET;
send_packet(sfd_client, chp);
recv_packet(sfd_client, chp);
//printpacket(chp, HP);
while(chp->type == REQU)
{
if(chp->comid == LMKDIR)
{
strcpy(temp, chp->buffer);
command_lmkdir(temp);
}
else if(chp->comid == LCD)
{
strcpy(temp, chp->buffer);
command_lcd(temp);
}
else if(chp->comid == GET)
{
strcpy(temp, chp->buffer);
command_get(sfd_client, chp, temp);
}
recv_packet(sfd_client, chp);
//printpacket(chp, HP);
}
if(chp->type == EOT)
printf("\tTransmission successfully ended.\n");
else
fprintf(stderr, "There was a problem completing the request.\n");
}
/*
err = MG_NET_RECVVAR(socket, variable)
Reads an IDL variable from the socket in the form written by MG_NET_SENDVAR.
The complete variable is reconstructed. See MG_NET_SENDVAR for more details.
*/
static IDL_VPTR IDL_CDECL mg_net_recvvar(int argc, IDL_VPTR argv[], char *argk) {
IDL_LONG i, iRet;
IDL_LONG swab = 0;
i_var var;
IDL_VPTR vpTmp;
char *pbuffer;
i = IDL_LongScalar(argv[0]);
if ((i < 0) || (i >= MAX_SOCKETS)) return (IDL_GettmpLong(-1));
if (net_list[i].iState != NET_IO) return (IDL_GettmpLong(-1));
IDL_EXCLUDE_EXPR(argv[1]);
/* read the header */
iRet = recv_packet(net_list[i].socket, &var,sizeof(i_var));
if (iRet == -1) return (IDL_GettmpLong(-1));
if (var.token == SWAPTOKEN) {
mg_byteswap(&var, sizeof(i_var), sizeof(IDL_LONG));
swab = 1;
}
if (var.token != TOKEN) return (IDL_GettmpLong(-1));
/* allocate the variable */
if (var.type == IDL_TYP_STRING) {
vpTmp = IDL_StrToSTRING("");
IDL_StrEnsureLength(&(vpTmp->value.str), var.len);
vpTmp->value.str.slen = var.len - 1;
pbuffer = vpTmp->value.str.s;
memset(pbuffer, 0x20, var.len-1);
pbuffer[var.len] = '\0';
IDL_VarCopy(vpTmp, argv[1]);
} else if (var.ndims != 0) {
pbuffer = IDL_MakeTempArray(var.type, var.ndims, var.dims, IDL_BARR_INI_NOP, &vpTmp);
IDL_VarCopy(vpTmp, argv[1]);
} else {
vpTmp = IDL_GettmpLong(0);
IDL_VarCopy(vpTmp, argv[1]);
IDL_StoreScalarZero(argv[1], var.type);
pbuffer = &(argv[1]->value.c);
}
/* read the data */
iRet = recv_packet(net_list[i].socket, pbuffer, var.len);
if (iRet == -1) return (IDL_GettmpLong(-1));
if (swab) {
int swapsize = var.len / var.nelts;
if ((var.type == IDL_TYP_COMPLEX)
|| (var.type == IDL_TYP_DCOMPLEX)) {
swapsize /= 2;
}
mg_byteswap(pbuffer, var.len, swapsize);
}
return (IDL_GettmpLong(1));
}
static int autofs_read(const char *path, char *buf, size_t size, off_t offset,
struct fuse_file_info *fi)
{
DBPRINTF("read %s\n", path);
shared_data *sd = get_sd();
// TODO (max size is 1 MB)
if (size > 1024*1024*512) {
fprintf(stderr, "Read is too big!\n");
exit(1);
}
ReqRead req_read;
req_read.set_filepath(path);
req_read.set_offset(offset);
req_read.set_length(size);
send_packet(sd->sock, REQ_READ, &req_read);
databuf dbuf;
if (recv_packet(sd->sock, NULL, &dbuf) != ERR_NONE) {
return -ENOENT;
}
// TODO: keep reading until full
size_t real_size = dbuf.size();
memcpy(buf, &dbuf[0], real_size);
return real_size;
}
static int autofs_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
off_t offset, struct fuse_file_info *fi)
{
DBPRINTF("autofs_readdir %s\n", path);
shared_data *sd = get_sd();
ReqListdir req_listdir;
req_listdir.set_dirpath(path);
send_packet(sd->sock, REQ_LISTDIR, &req_listdir);
RespListdir rl;
if (recv_packet(sd->sock, &rl) != ERR_NONE) {
return -ENOENT;
}
filler(buf, ".", NULL, 0);
filler(buf, "..", NULL, 0);
for (int i = 0; i < rl.entries_size(); i++) {
const RespListdir::ListdirEntry &entry = rl.entries(i);
DBPRINTF("Reading entry %d (%s)\n", i, entry.filename().c_str());
filler(buf, entry.filename().c_str(), NULL, 0);
}
return 0;
}
int
vhost_client_poll_client_rx(void *context, void *dst_buf, size_t *dst_buf_len) {
Vhost_Client *vhost_client = NULL;
VHOST_CLIENT_VRING vq_id = VHOST_CLIENT_VRING_IDX_RX;
VIRT_QUEUE_H_RET_VAL virt_queue_ret_val = E_VIRT_QUEUE_OK;
if (!context || !dst_buf ) {
return map_ret_val_virt_queue_2_vhost_net(E_VIRT_QUEUE_ERR_FARG);
}
vhost_client = (Vhost_Client *) context;
virt_queue_ret_val = recv_packet((vhost_client->virtq_control[vq_id]),
(uint64_t *)dst_buf, dst_buf_len);
if (virt_queue_ret_val == E_VIRT_QUEUE_OK) {
virt_queue_process_used_rx_virt_queue(vhost_client->virtq_control, vq_id);
}
//TODO: Burst
virt_queue_put_rx_virt_queue(vhost_client->virtq_control,
vq_id, ETH_MAX_MTU);
return map_ret_val_virt_queue_2_vhost_net(virt_queue_ret_val);
}
void ping(int argc, char **argv)
{
int err;
/* init options */
init_options();
/* parse args */
if ((err = parse_args(argc, argv)) < 0) {
if (err == -1)
usage();
return;
}
/* signal install */
signal(SIGALRM, sigalrm);
signal(SIGINT, sigint);
/* address */
skaddr.dst_addr = ipaddr;
sock = _socket(AF_INET, SOCK_RAW, IP_P_ICMP);
/* send request */
sigalrm(SIGALRM);
/* receive reply */
recv_packet();
alarm(0);
close_socket();
if (buf)
free(buf);
ping_stat();
}
void connect_handshake(int sock_num) {
//debug_max("--------- receive handshake packet -------\n");
/* Receive the handshake packet */
// We don't care what is in it, just that it was a packet sent
// to the main server thread
char * data_buff = malloc(HS_PKT_SZ);
struct sockaddr_in cli_addr;
recv_packet(sock_num, data_buff, HS_PKT_SZ, &cli_addr);
//int bytes_trfd = recv_packet(sock_num, data_buff, HS_PKT_SZ, &cli_addr);
//debug_max("connect_handshake(): bytes_trfd = %i\n", bytes_trfd);
/* Create new socket and pass it to a new thread */
pthread_t thr_1;
int thr_id;
int new_sock_num;
if ((new_sock_num = create_udp_srv_sock(0)) < 0) { // didn't work
debug_print("connect_handshake() : cannot open new socket to client");
} else {
// send ack on new port
send_ack(new_sock_num, &cli_addr, HS_SEQ_NUM, ACK_PKT_TYPE);
thr_id = pthread_create(&thr_1, NULL, do_threading, (void *) new_sock_num);
//debug_min("connect_handshake() 3: thr_id = %i\n", thr_id);
}
}
void command_put(int sfd_client, struct packet* chp, char* filename)
{
FILE* f = fopen(filename, "rb"); // Yo!
if(!f)
{
fprintf(stderr, "File could not be opened for reading. Aborting...\n");
return;
}
clear_packet(chp);
chp->type = REQU;
chp->comid = PUT;
strcpy(chp->buffer, filename);
send_packet(sfd_client, chp);
recv_packet(sfd_client, chp);
//printpacket(chp, HP);
if(chp->type == INFO && chp->comid == PUT && strlen(chp->buffer))
{
printf("\t%s\n", chp->buffer);
chp->type = DATA;
send_file(sfd_client, chp, f);
fclose(f);
}
else
fprintf(stderr, "Error sending file.\n");
send_EOT(sfd_client, chp);
}
static int xfer(sport_t fd,
uint8_t app, uint8_t verb, uint16_t len,
const uint8_t *data, struct packet *pkt)
{
if (send_packet(fd, app, verb, len, data) < 0)
goto fail;
while (recv_packet(fd, pkt) >= 0) {
if (pkt->app == APP_DEBUG && pkt->verb == GLOBAL_DEBUG) {
char text[MAX_LEN + 1];
memcpy(text, pkt->data, pkt->len);
text[pkt->len] = 0;
printc_dbg("[GoodFET debug] %s\n", text);
}
if (pkt->app == app && pkt->verb == verb)
return 0;
}
fail:
printc_err("goodfet: command 0x%02x/0x%02x "
"failed\n", app, verb);
return -1;
}
void resend_fin_pkt(void *opaque) {
INFO("Resending the ACK in response to the FIN%s\n", "");
packet_t pkt;
// Read the packet from the socket.
recv_packet(&pkt);
uint32_t cur_ms = current_time_in_ms();
uint32_t elapsed_ms = cur_ms - at_select_ms;
if (elapsed_ms <= time_av_ms) {
time_av_ms -= elapsed_ms;
at_select_ms = cur_ms;
} else {
time_av_ms = 0;
}
fds.timeout.tv_sec = time_av_ms / 1000;
fds.timeout.tv_usec = (time_av_ms % 1000) * 1000;
memset(&pkt, 0, sizeof(pkt));
pkt.ack = rwin.smallest_expected_seq;
pkt.datalen = 0;
pkt.rwinsz = 0;
send_packet(&pkt);
INFO("Waiting for %d more seconds in the TIME_WAIT state\n", time_av_ms/1000);
}
//OPS_PMS_LOGIN_RESP_OK
int handle_ops_pms_login_resp_ok(void *args)
{
struct packet *pkt = (struct packet*)args;
DEBUG(INFO, "%s %d %d %u handle",pkt->ip, pkt->sockfd, pkt->ops_type, pkt->len);
#ifndef OSPF_VERSION
return 0;
#endif
int ret = 0;
ret = recv_packet(pkt, 0);
if(ret == -1)
{
DEBUG(INFO, "%s %d %d %u handle_ops_pms_login_resp_ok handle :recv packet failed",pkt->ip, pkt->sockfd, pkt->ops_type, pkt->len);
return -1;
}
DEBUG(INFO, "%s %d %d %u RECEIVE POLICY DATA",pkt->ip, pkt->sockfd, pkt->ops_type, pkt->len);
DEBUG(DATA, "%s", pkt->data + sizeof(struct pma_pms_header));
int len = pkt->len - sizeof(struct pma_pms_header);
xml_policy_buff.buff = (char*)malloc(len);
xml_policy_buff.length = len;
memcpy(xml_policy_buff.buff, pkt->data + sizeof(struct pma_pms_header),xml_policy_buff.length);
printf("%d %s\n",xml_policy_buff.length, xml_policy_buff.buff);
DEBUG(INFO, "%s %d %d %u POLICY PROCESS SUCCEED",pkt->ip, pkt->sockfd, pkt->ops_type, pkt->len);
return 0;
}
/*****************************************************************************
Prototype : detector_uart_run
Description : run detect
Input : DetectorHandle hDetector
CaptureInfo *capInfo
Output : None
Return Value : static
Calls :
Called By :
History :
1.Date : 2012/4/6
Author : Sun
Modification : Created function
*****************************************************************************/
static Int32 detector_uart_run(DetectorHandle hDetector, CaptureInfo *capInfo)
{
Uint8 rxBuf[RX_BUF_SIZE];
Int32 status = E_NO;
Int32 i;
DetectorUart *dev = DETECTOR_GET_PRIVATE(hDetector);
const CamDetectorParam *params = DETECTOR_GET_PARAMS(hDetector);
TriggerInfo *trigInfo = &capInfo->triggerInfo[0];
Int32 start = 0, offset = 0, recvLen;
if(!capInfo || !dev || !params)
return E_INVAL;
/* Clear cap count */
capInfo->capCnt = 0;
capInfo->flags = 0;
/* Recieve and parse trigger data */
for(i = 0; i < APP_MAX_CAP_CNT; i++) {
/* Check if there is trigger data recved */
status = recv_packet(dev, rxBuf + start, &offset, sizeof(rxBuf) - offset - start);
if(status < 0) {
break;
}
/* Parse trigger data */
recvLen = status;
start += offset;
status = dev->opts->singleTrigParse(dev, params, rxBuf + start, trigInfo);
if(!status) {
capInfo->capCnt++;
/* set flags for top level flags */
if(trigInfo->flags & TRIG_INFO_DELAY_CAP)
capInfo->flags |= CAPINFO_FLAG_DELAY_CAP;
if(trigInfo->flags & TRIG_INFO_OVERSPEED)
capInfo->flags |= CAPINFO_FLAG_OVERSPEED;
#ifdef UART_DEBUG
DBG("got trig data, way: %d, frame num: %d", trigInfo->wayNum, trigInfo->frameId);
#endif
trigInfo++;
}
/* Move to next packet */
start += dev->packetLen;
offset = recvLen - dev->packetLen;
if(offset)
usleep(5000);
}
/* We have received some data */
if(capInfo->capCnt) {
return E_NO;
}
return status;
}
static bool server_recv_packet(Client *c, Packet *pkt) {
if (recv_packet(c->socket, pkt)) {
print_packet("server-recv:", pkt);
return true;
}
debug("server-recv: FAILED\n");
c->state = STATE_DISCONNECTED;
return false;
}
int main(int argc, char *argv[])
{
int skt;
int size, rt;
unsigned char buf[4096];
struct sockaddr sa;
int asize;
/* Check our huge range of flags */
if (argc > 1)
{
if (strcmp(argv[1], "-v") == 0 || strcmp(argv[1], "-h") ==0)
{
printf("axdigi version %s. Copyright (C) 1995 Craig Small VK2XLZ\n\n", VERSION);
printf("axdigi comes with ABSOLUTELY NO WARRANTY.\n");
printf("This is free software, and you are welcome to redistribute it\n");
printf("under the terms of GNU General Public Licence as published\n");
printf("by Free Software Foundation; either version 2 of the License, or\n");
printf("(at your option) any later version.\n");
return 0;
}
}
if ((skt = socket(AF_INET, SOCK_PACKET, htons(ETH_P_AX25))) == -1)
{
perror("socket");
return(1);
}
get_interfaces(skt);
while(1)
{
asize = sizeof(sa);
if ((size = recvfrom(skt, buf, sizeof(buf), 0, &sa, &asize)) == -1)
{
perror("recv");
exit(1);
}
if ((rt = recv_packet(buf, size, sa.sa_data)) >= 0)
{
if (rt < port_count)
{
asize = sizeof(sa);
strcpy(sa.sa_data, portname[rt]);
if (sendto(skt, buf, size, 0, &sa, asize) == -1)
perror("sendto");
continue;
}
/* printf("Unknown port %s\n", sa.sa_data);*/
} /* recv_packet true */
} /* while(1) */
close(skt);
}
void command_pwd(int sfd_client, struct packet* chp)
{
clear_packet(chp);
chp->type = REQU;
chp->comid = PWD;
send_packet(sfd_client, chp);
recv_packet(sfd_client, chp);
if(chp->type == DATA && chp->comid == PWD && strlen(chp->buffer) > 0)
printf("\t%s\n", chp->buffer);
else
fprintf(stderr, "\tError retrieving information.\n");
}
static int autofs_stat(const char *path, struct stat *stbuf) {
memset(stbuf, 0, sizeof(struct stat));
stbuf->st_uid = geteuid();
stbuf->st_gid = getegid();
shared_data *sd = get_sd();
ReqStat req_stat;
req_stat.set_filepath(path);
// Send request
if (send_packet(sd->sock, REQ_STAT, &req_stat) < 0) {
return -EIO;
}
DBPRINTF("stat %s\n", path);
// Get response
RespStat sr;
ErrorCode afs_err = recv_packet(sd->sock, &sr);
if (afs_err != ERR_NONE) {
return -ENOENT;
}
time_t mtime_utc = sr.mtime_utc();
struct tm *tm_loc = localtime(&mtime_utc);
time_t mtime_local = mktime(tm_loc);
stbuf->st_ctime = mtime_local;
stbuf->st_mtime = mtime_local;
stbuf->st_atime = mtime_local;
if (sr.ftype() & S_IFDIR) {
stbuf->st_mode = S_IFDIR | sr.perms();
stbuf->st_nlink = sr.size();
stbuf->st_ino = sr.inode();
DBPRINTF("result dir\n");
return 0;
}
else if (sr.ftype() & S_IFREG) {
stbuf->st_mode = S_IFREG | sr.perms();
stbuf->st_nlink = 1;
stbuf->st_size = sr.size();
stbuf->st_ino = sr.inode();
DBPRINTF("result file, size %lu b\n", sr.size());
//DBPRINTF("ctime_utc %d, ctime %d, %s", ctime_utc, stbuf->st_ctime, ctime(&ctime_utc));
return 0;
}
DBPRINTF("result NOENT\n");
return -ENOENT;
}
static irqreturn_t nfeth_interrupt(int irq, void *dev_id)
{
int i, m, mask;
mask = nf_call(nfEtherID + XIF_IRQ, 0);
for (i = 0, m = 1; i < MAX_UNIT; m <<= 1, i++) {
if (mask & m && nfeth_dev[i]) {
recv_packet(nfeth_dev[i]);
nf_call(nfEtherID + XIF_IRQ, m);
}
}
return IRQ_HANDLED;
}
/*
a client wants to send us something, or has exited
*/
static void client_input(struct client *c)
{
size_t len;
char *inbuf;
if (recv_packet(c->fd, &inbuf, &len) != 0) {
dead_client(c);
return;
}
process_request(c, inbuf, len);
free(inbuf);
}
void command_cd(int sfd_client, struct packet* chp, char* path)
{
clear_packet(chp);
chp->type = REQU;
chp->comid = CD;
strcpy(chp->buffer, path);
send_packet(sfd_client, chp);
recv_packet(sfd_client, chp);
if(chp->type == INFO && chp->comid == CD && !strcmp(chp->buffer, "success"))
;
else
fprintf(stderr, "\tError executing command on the server.\n");
}
static int autofs_unlink(const char *path)
{
DBPRINTF("unlink %s\n", path);
shared_data *sd = get_sd();
ReqUnlink req_unlink;
req_unlink.set_filepath(path);
send_packet(sd->sock, REQ_UNLINK, &req_unlink);
if (recv_packet(sd->sock, NULL, NULL) != ERR_NONE) {
return -EIO;
}
return 0;
}
main(int argc,char *argv[])
{ struct hostent *host;
struct protoent *protocol;
unsigned long inaddr=0l;
int waittime=MAX_WAIT_TIME;
int size=50*1024;
if(argc<2)
{ printf("usage:%s hostname/IP address\n",argv[0]);
exit(1);
}
if( (protocol=getprotobyname("icmp") )==NULL)
{ perror("getprotobyname");
exit(1);
}
/*生成使用ICMP的原始套接字,这种套接字只有root才能生成*/
if( (sockfd=socket(AF_INET,SOCK_RAW,protocol->p_proto) )<0)
{ perror("socket error");
exit(1);
}
/* 回收root权限,设置当前用户权限*/
setuid(getuid());
/*扩大套接字接收缓冲区到50K这样做主要为了减小接收缓冲区溢出的
的可能性,若无意中ping一个广播地址或多播地址,将会引来大量应答*/
setsockopt(sockfd,SOL_SOCKET,SO_RCVBUF,&size,sizeof(size) );
bzero(&dest_addr,sizeof(dest_addr));
dest_addr.sin_family=AF_INET;
/*判断是主机名还是ip地址*/
if( inaddr=inet_addr(argv[1])==INADDR_NONE)
{ if((host=gethostbyname(argv[1]) )==NULL) /*是主机名*/
{ perror("gethostbyname error");
exit(1);
}
memcpy( (char *)&dest_addr.sin_addr,host->h_addr,host->h_length);
}
else /*是ip地址*/
memcpy( (char *)&dest_addr,(char *)&inaddr,host->h_length);
/*获取main的进程id,用于设置ICMP的标志符*/
pid=getpid();
printf("PING %s(%s): %d bytes data in ICMP packets.\n",argv[1],
inet_ntoa(dest_addr.sin_addr),datalen);
send_packet(); /*发送所有ICMP报文*/
recv_packet(); /*接收所有ICMP报文*/
statistics(SIGALRM); /*进行统计*/
return 0;
}
main(int argc,char *argv[])
{ struct hostent *host;
struct protoent *protocol;
unsigned long inaddr=0l;
int waittime=MAX_WAIT_TIME;
int size=50*1024;
if(argc<2)
{ printf("usage:%s hostname/IP address\n",argv[0]);
exit(1);
}
if( (protocol=getprotobyname("icmp") )==NULL)
{ perror("getprotobyname");
exit(1);
}
if( (sockfd=socket(AF_INET,SOCK_RAW,protocol->p_proto) )<0)
{ perror("socket error");
exit(1);
}
setuid(getuid());
setsockopt(sockfd,SOL_SOCKET,SO_RCVBUF,&size,sizeof(size) );
bzero(&dest_addr,sizeof(dest_addr));
dest_addr.sin_family=AF_INET;
if( inaddr=inet_addr(argv[1])==INADDR_NONE)
{ if((host=gethostbyname(argv[1]) )==NULL)
{ perror("gethostbyname error");
exit(1);
}
memcpy( (char *)&dest_addr.sin_addr,host->h_addr,host->h_length);
}
else
memcpy( (char *)&dest_addr,(char *)&inaddr,host->h_length);
pid=getpid();
printf("PING %s(%s): %d bytes data in ICMP packets.\n",argv[1],
inet_ntoa(dest_addr.sin_addr),datalen);
send_packet();
recv_packet();
statistics(SIGALRM);
return 0;
}
int main(int argc, char *argv[])
{
int sockfd;
int pkt_size = 3000;
int opt;
int addr_family = AF_INET6; /* Default address family */
uint16_t dest_port = PORT;
char *dest_ip;
int len_send, len_recv;
char buf_send[65535], buf_recv[65535];
/* Adding support for both IPv4 and IPv6 */
struct sockaddr_storage dest_addr; /* Can contain both sockaddr_in and sockaddr_in6 */
memset(&dest_addr, 0, sizeof(dest_addr));
while ((opt = getopt(argc, argv, "s:64v:p:")) != -1) {
if (opt == 's') pkt_size = atoi(optarg);
if (opt == '4') addr_family = AF_INET;
if (opt == '6') addr_family = AF_INET6;
if (opt == 'v') verbose = atoi(optarg);
if (opt == 'p') dest_port = atoi(optarg);
}
if (optind >= argc) {
fprintf(stderr, "Expected dest IP-address (IPv6 or IPv4) argument after options\n");
exit(2);
}
dest_ip = argv[optind];
if (verbose > 0)
printf("Destination IP:%s port:%d\n", dest_ip, dest_port);
sockfd = socket(addr_family, SOCK_DGRAM, 0);
/* Socket options, see man-pages ip(7) and ipv6(7) */
//int set_pmtu_disc = IP_PMTUDISC_DO; /* do PMTU = Don't Fragment */
int set_pmtu_disc = IP_PMTUDISC_DONT; /* Allow fragments, dont do PMTU */
Setsockopt(sockfd, IPPROTO_IP, IP_MTU_DISCOVER, &set_pmtu_disc, sizeof(int));
Setsockopt(sockfd, IPPROTO_IPV6, IPV6_MTU_DISCOVER, &set_pmtu_disc, sizeof(int));
/* Setup dest_addr depending on IPv4 or IPv6 address */
setup_sockaddr(addr_family, &dest_addr, dest_ip, dest_port);
/* Connect to recv ICMP error messages */
connect(sockfd, (struct sockaddr *)&dest_addr,
sockaddr_len(&dest_addr));
len_send = send_packet(sockfd, &dest_addr, buf_send, pkt_size);
len_recv = recv_packet(sockfd, &dest_addr, buf_recv, len_send);
validate_packet(len_send, len_recv, buf_send, buf_recv);
}
static int autofs_rename(const char *old_path, const char *new_path)
{
DBPRINTF("rename %s => %s\n", old_path, new_path);
shared_data *sd = get_sd();
ReqRename req_rename;
req_rename.set_old_path(old_path);
req_rename.set_new_path(new_path);
send_packet(sd->sock, REQ_RENAME, &req_rename);
if (recv_packet(sd->sock, NULL, NULL) != ERR_NONE) {
return -EIO;
}
return 0;
}
int detect_ipc_online(char *ipaddr)
{
nsend=0;
nreceived=0;
unreceived=0;
dest_addr.sin_addr.s_addr = inet_addr(ipaddr);
pid=getpid(); /*获取进程id,用于设置ICMP的标志符*/
send_packet(); /*发送所有ICMP报文*/
recv_packet(); /*接收所有ICMP报文*/
return nreceived; //nreceived=3 for ping success
}
static int autofs_truncate(const char *path, off_t new_size)
{
DBPRINTF("truncate %s\n", path);
if (new_size < 0) return -EINVAL;
shared_data *sd = get_sd();
ReqTruncate req_truncate;
req_truncate.set_filepath(path);
req_truncate.set_newlength(new_size);
send_packet(sd->sock, REQ_TRUNCATE, &req_truncate);
if (recv_packet(sd->sock, NULL, NULL) != ERR_NONE) {
return -EIO;
}
return 0;
}
void command_ls(int sfd_client, struct packet* chp)
{
clear_packet(chp);
chp->type = REQU;
chp->comid = LS;
send_packet(sfd_client, chp);
while(chp->type != EOT)
{
if(chp->type == DATA && chp->comid == LS && strlen(chp->buffer))
printf("\t%s\n", chp->buffer);
/*
else
fprintf(stderr, "\tError executing command on the server.\n");
*/
recv_packet(sfd_client, chp);
}
}
/*
* Read the next data packet from a TFTP connection
*/
static int tftp_get_block (const char **buf)
{
int retry;
/* Don't do anything if no TFTP connection is active.
*/
if (!isopen)
return (0);
/* If the block number is 0 then we are still dealing with the first
* data block after opening a connection. If the data size is smaller
* than 'blocksize' just close the connection again.
*/
if (currblock == 0UL)
{
currblock++;
if (ibuflen < blocksize)
isopen = FALSE;
*buf = (const char*) &inbuf->th_data[0];
return (ibuflen);
}
/* Wait for the next data packet. If no data packet is coming in,
* resend the ACK for the last packet to restart the sender. Maybe
* he didn't get our first ACK.
*/
for (retry = 0; retry < tftp_retry; retry++)
{
ibuflen = recv_packet (currblock+1);
if (ibuflen >= 0)
{
currblock++;
send_ack ((WORD)currblock);
if (ibuflen < blocksize) /* last block received */
isopen = FALSE;
*buf = (const char*) &inbuf->th_data[0];
return (ibuflen);
}
if (tftp_errno == ERR_ERR || tftp_errno == ERR_UNKNOWN)
break;
send_ack ((WORD)currblock);
}
isopen = FALSE;
return (-1);
}
void dhcp_ack()
{
if (next_state != ACK) {
fprintf(err, "State is not ACK!\n");
return;
}
struct dhcp_packet *packet = malloc(sizeof(struct dhcp_packet));
memset(packet, 0, sizeof(struct dhcp_packet));
int valid = 0;
while (!valid) {
int len = recv_packet((char*)packet, sizeof(struct dhcp_packet));
if (len < 0) {/* timeout */
free_socket();
if (timeout_count--) {
next_state = REQUEST;
dhcp_request();
return;
} else {
if (renew) {
fprintf(err, "Failed to renew, try to re-allocate\n");
timeout_count = TIMEOUT_RETRY_TIMES;
next_state = DISCOVER;
dhcp_discover();
return;
} else {
//fprintf(err, "give up...\n");
//exit(0);
fprintf(err, "Error in dhcp_ack, sleep 60s...\n");
sleep(60);
timeout_count = TIMEOUT_RETRY_TIMES;
next_state = DISCOVER;
dhcp_discover();
return;
}
}
}
valid = check_packet(packet);
}
process_lease(&ack_lease, packet);
free(packet);
free_socket();
configure_interface(&ack_lease);
}
/****************************************************************
* Receives msgs formatted to the SLIP protocol (ie. over UART)
* and publishes them as raw data
*/
void SlipProtocol::callbackReceive(const fmMsgs::serial_bin::ConstPtr& msg){
for (int i = 0; i < msg->data.size(); i++){
if ((int)recv_packet(slip_rx_buffer, msg->data[i])){
++unwrapped_msg.header.seq;
unwrapped_msg.data.clear();
while (!slip_rx_buffer.empty()){ // Cleares the buffer again as well
unwrapped_msg.data.push_back(slip_rx_buffer.front());
slip_rx_buffer.pop_front();
}
unwrapped_msg.length = unwrapped_msg.data.size();
ros::Time start = ros::Time::now();
unwrapped_msg.header.stamp = start;
slip_unwrapped.publish(unwrapped_msg);
}
}
}
