void send_mputw_files(char *w_pattern){
short byte_no = 0, buf_byte = 0, file_no = 0, filename_byte = 0, buffer_byte = 0, last_file = 0;
char baseDir[DIR_LENGTH], ch_file = ' ', filename[BUF_SIZE], ch = ' ';
DIR *dp;
struct dirent *dirp;
struct stat isdir;
FILE *file_ptr;
strcpy(baseDir, ".");
if((dp = opendir(baseDir)) == NULL){
fprintf(stdout, "Couldn't open %s\n", baseDir);
return;
}
while((dirp = readdir(dp)) != NULL){
if ( !strcmp(dirp->d_name, ".") || !strcmp(dirp->d_name, "..") || (!stat(dirp->d_name, &isdir) && (isdir.st_mode & S_IFDIR)) || fnmatch(w_pattern, dirp->d_name, FNM_FILE_NAME) != 0){
fprintf(stdout, "send_mputw_files() : not match : %s\n", dirp->d_name);
continue;
}
strncpy(filename, dirp->d_name, BUF_SIZE);
fprintf(stdout, "send_mputw_files() : filename : %s\n", filename);
for(filename_byte = 0; filename[filename_byte] != '\0'; filename_byte++){
ch = filename[filename_byte];
if(buffer_byte != BUF_SIZE - 1)
buffer[buffer_byte++] = ch;
else{
buffer[buffer_byte] = '\0';
buffer_byte = 0;
fprintf(stdout, "send_mputw_files() : buffer : %s\n", buffer);
send_pack((enum commands)1, buffer, request->serverSocket);
}
}
if(buffer_byte == BUF_SIZE - 1){
buffer[buffer_byte] = '\0';
buffer_byte = 0;
send_pack((enum commands)1, buffer, request->serverSocket);
}
buffer[buffer_byte++] = '\t';
file_ptr = fopen(filename, "r");
ch_file = ' ';
do{
if(buffer_byte != BUF_SIZE - 1){
ch_file = fgetc(file_ptr);
buffer[buffer_byte++] = ch_file;
}
if(buffer_byte == BUF_SIZE - 1){
buffer[buffer_byte] = '\0';
buffer_byte = 0;
send_pack((enum commands)1, buffer, request->serverSocket);
}
}while(ch_file != EOF);
fclose(file_ptr);
}
if(buffer_byte){
buffer[buffer_byte] = '\0';
send_pack((enum commands)1, buffer, request->serverSocket);
}
}
void mget(){
int no_files = 0;
char **file_list, packet_file_list[BUF_SIZE];
fprintf(stdout, "mget() : argument list : %s\n", command.arguments);
// parse the list of files //
no_files = parse_file_list(command.arguments, packet_file_list);
fprintf(stdout, "mget() : packet_file_list : %s\n", packet_file_list);
file_list = (char**)malloc(no_files*sizeof(char*));
parse_file_list(packet_file_list, file_list);
// Send command //
send_pack(MGET, packet_file_list, sock);
fprintf(stdout, "mget() : packet_str : %s\n", packet_str);
/* send port number for data connection to server */
send_data_port();
// make socket and accept server's Data Connection (active)//
makeDataConnection();
fprintf(stderr, "get() : data connection accepted\n");
// recieve files //
receive_multiple_files(no_files, file_list);
fprintf(stdout, "get() : files completely received\n");
fflush(stdout);
// close the data connection //
close(request->serverSocket);
}
void put(){
strcpy(filename, command.arguments);
fprintf(stdout, "put() : %s\n", filename);
// check if the file exists //
FILE *file_ptr = fopen(filename, "r");
if(!file_ptr){
fprintf(stderr, "The specified does not exist\n");
return;
}
// Send command //
send_pack(PUT, command.arguments, sock);
fprintf(stdout, "%s\n", packet_str);
/* send port number for data connection to server */
send_data_port();
// make socket and accept server's Data Connection (active)//
makeDataConnection();
fprintf(stderr, "put() : data connection accepted\n");
// send file //
sendFile(file_ptr);
fprintf(stdout, "put() : complete file sent\n");
fflush(stdout);
//close the file
fclose(file_ptr);
// close the data connection //
close(request->serverSocket);
}
static int git_transport_push(struct transport *transport, struct ref *remote_refs, int flags)
{
struct git_transport_data *data = transport->data;
struct send_pack_args args;
int ret;
if (!data->conn) {
struct ref *tmp_refs;
connect_setup(transport, 1, 0);
get_remote_heads(data->fd[0], &tmp_refs, 0, NULL, REF_NORMAL,
NULL);
}
args.send_mirror = !!(flags & TRANSPORT_PUSH_MIRROR);
args.force_update = !!(flags & TRANSPORT_PUSH_FORCE);
args.use_thin_pack = data->thin;
args.verbose = !!(flags & TRANSPORT_PUSH_VERBOSE);
args.dry_run = !!(flags & TRANSPORT_PUSH_DRY_RUN);
ret = send_pack(&args, data->fd, data->conn, remote_refs,
&data->extra_have);
close(data->fd[1]);
close(data->fd[0]);
ret |= finish_connect(data->conn);
data->conn = NULL;
return ret;
}
void get(){
// Send command //
send_pack(GET, command.arguments, sock);
// receive positive/negative acknowledgement (whether the file exists or not) //
if(recv(sock, packet_str, PACK_SIZE, 0) < 0){
error("recv");
}
parse_packet(packet_str, packet);
if(!(int)packet.command_code){
fprintf(stderr, "The specified does not exist\n");
return;
}
/* send port number for data connection to server */
send_data_port();
// make socket and accept server's Data Connection (active)//
makeDataConnection();
fprintf(stderr, "get() : data connection accepted\n");
// recieve file //
receive_file();
fprintf(stdout, "get() : complete file received\n");
fflush(stdout);
// close the data connection //
close(request->serverSocket);
}
static int git_transport_push(struct transport *transport, struct ref *remote_refs, int flags)
{
struct git_transport_data *data = transport->data;
struct send_pack_args args;
int ret;
if (!data->got_remote_heads) {
struct ref *tmp_refs;
connect_setup(transport, 1, 0);
get_remote_heads(data->fd[0], &tmp_refs, REF_NORMAL, NULL);
data->got_remote_heads = 1;
}
memset(&args, 0, sizeof(args));
args.send_mirror = !!(flags & TRANSPORT_PUSH_MIRROR);
args.force_update = !!(flags & TRANSPORT_PUSH_FORCE);
args.use_thin_pack = data->options.thin;
args.verbose = (transport->verbose > 0);
args.quiet = (transport->verbose < 0);
args.progress = transport->progress;
args.dry_run = !!(flags & TRANSPORT_PUSH_DRY_RUN);
args.porcelain = !!(flags & TRANSPORT_PUSH_PORCELAIN);
ret = send_pack(&args, data->fd, data->conn, remote_refs,
&data->extra_have);
close(data->fd[1]);
close(data->fd[0]);
ret |= finish_connect(data->conn);
data->conn = NULL;
data->got_remote_heads = 0;
return ret;
}
void rputdir(){
DIR *dp = opendir(command.arguments);
allzero(buffer, 1);
if(!dp){
fprintf(stdout, "The specified folder does not exist\n");
return;
}
closedir(dp);
// send command //
send_pack(RPUTDIR, command.arguments, sock);
/* send port number for data connection to server */
send_data_port();
// make socket and accept server's Data Connection (active)//
makeDataConnection();
fprintf(stderr, "rputdir() : data connection accepted\n");
// recieve file //
send_rputdir_files(command.arguments);
fprintf(stdout, "rputdir() : files completely sent\n");
fflush(stdout);
// close the data connection //
close(request->serverSocket);
//close(sock_data);
}
void mput(){
// Send command //
allzero(buffer, 1);
send_pack(MPUT, buffer, sock);
fprintf(stdout, "mput() : packet_str : %s\n", packet_str);
/* send port number for data connection to server */
send_data_port();
// make socket and accept server's Data Connection (active)//
makeDataConnection();
fprintf(stderr, "mput() : data connection accepted\n");
// send files //
sendMultipleFiles(command.arguments);
fprintf(stdout, "mput() : files completely sent\n");
fflush(stdout);
// close the data connection //
close(request->serverSocket);
/*
if(setsockopt(sock_data, SOL_SOCKET, SO_REUSEADDR, (void*)&optval, sizeof(int)) < 0){
error("setsockopt") ;
}
*/
}
void rgetdir(){
// prepare packet to be sent //
send_pack(RGETDIR, command.arguments, sock);
// receive positive/negative acknowledgement (whether the file exists or not) //
strncpy(packet_str, "", PACK_SIZE);
if(recv(sock, packet_str, PACK_SIZE, 0) < 0){
error("recv");
}
parse_packet(packet_str, packet);
if(packet.command_code == INVALID){
fprintf(stderr, "The specified folder does not exist\n");
return;
}
mkdir(command.arguments, S_IRWXU | S_IRWXG | S_IRWXO);
/* send port number for data connection to server */
send_data_port();
// make socket and accept server's Data Connection (active)//
makeDataConnection();
fprintf(stderr, "rgetdir() : data connection accepted\n");
// recieve files //
receive_rgetdir_files();
fprintf(stdout, "rgetdir() : files completely received\n");
fflush(stdout);
// close the data connection //
close(request->serverSocket);
//close(sock_data);
}
static int git_transport_push(struct transport *transport, struct ref *remote_refs, int flags)
{
struct git_transport_data *data = transport->data;
struct send_pack_args args;
int ret = 0;
if (transport_color_config() < 0)
return -1;
if (!data->got_remote_heads)
get_refs_via_connect(transport, 1, NULL);
memset(&args, 0, sizeof(args));
args.send_mirror = !!(flags & TRANSPORT_PUSH_MIRROR);
args.force_update = !!(flags & TRANSPORT_PUSH_FORCE);
args.use_thin_pack = data->options.thin;
args.verbose = (transport->verbose > 0);
args.quiet = (transport->verbose < 0);
args.progress = transport->progress;
args.dry_run = !!(flags & TRANSPORT_PUSH_DRY_RUN);
args.porcelain = !!(flags & TRANSPORT_PUSH_PORCELAIN);
args.atomic = !!(flags & TRANSPORT_PUSH_ATOMIC);
args.push_options = transport->push_options;
args.url = transport->url;
if (flags & TRANSPORT_PUSH_CERT_ALWAYS)
args.push_cert = SEND_PACK_PUSH_CERT_ALWAYS;
else if (flags & TRANSPORT_PUSH_CERT_IF_ASKED)
args.push_cert = SEND_PACK_PUSH_CERT_IF_ASKED;
else
args.push_cert = SEND_PACK_PUSH_CERT_NEVER;
switch (data->version) {
case protocol_v2:
die(_("support for protocol v2 not implemented yet"));
break;
case protocol_v1:
case protocol_v0:
ret = send_pack(&args, data->fd, data->conn, remote_refs,
&data->extra_have);
break;
case protocol_unknown_version:
BUG("unknown protocol version");
}
close(data->fd[1]);
close(data->fd[0]);
ret |= finish_connect(data->conn);
data->conn = NULL;
data->got_remote_heads = 0;
return ret;
}
/**
* Send out an ARP packet.
*/
static void arp(int fd, struct sockaddr_ll *saddr, int op,
struct ether_addr *source_addr, struct in_addr source_ip,
struct ether_addr *target_addr, struct in_addr target_ip)
{
struct sockaddr_ll he;
// set broadcust mode
he = *saddr;
memset(he.sll_addr, -1, he.sll_halen);
send_pack(fd, saddr, &he, op, source_addr, &source_ip, target_addr, &target_ip);
return;
}
void* send_pthread(void* arg)
{
while(1)
{
printf("wait mutex unlock\n");
pthread_mutex_lock(&net_mutex);
sem_wait(®et[1]);
printf("get reget[1] sem\n");
send_pack();
pthread_mutex_unlock(&net_mutex);
usleep(5000);
}
}
static int git_transport_push(struct transport *transport, int refspec_nr, const char **refspec, int flags)
{
struct git_transport_data *data = transport->data;
struct send_pack_args args;
args.receivepack = data->receivepack;
args.send_all = !!(flags & TRANSPORT_PUSH_ALL);
args.send_mirror = !!(flags & TRANSPORT_PUSH_MIRROR);
args.force_update = !!(flags & TRANSPORT_PUSH_FORCE);
args.use_thin_pack = data->thin;
args.verbose = !!(flags & TRANSPORT_PUSH_VERBOSE);
args.dry_run = !!(flags & TRANSPORT_PUSH_DRY_RUN);
return send_pack(&args, transport->url, transport->remote, refspec_nr, refspec);
}
int main(int c, char **v)
{
int sfd, ret, ifindex, i = 1;
char ipsrc[16], ipdst[16], iptmp[16];
char device[12], src_mac[ETH_ALEN];
struct in_addr src, gatWay, traget;
struct sockaddr_ll from;
send_arping_t rbuf, gatWaybuf;
setuid(0);
sfd = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ARP));
if (sfd == -1){
perror("socket:");
return 1;
}
gethostip(sfd, device, &ifindex, ipsrc, sizeof(ipsrc));
inet_pton(AF_INET, ipsrc, &src.s_addr);
gethostmac(sfd, device, src_mac);
init_sfd(sfd, ifindex);
packed_for_ip(ipsrc, iptmp);
sprintf(ipdst, "%s%d", iptmp, i);
inet_pton(AF_INET, ipdst, &gatWay.s_addr);
while (1){
send_pack(sfd, src_mac, ifindex, &src, &gatWay);
if (recv_pack(sfd, &gatWay, &gatWaybuf))
continue;
else
break;
}
while (1){
printf("which one you want to attacked: ");
fflush(stdout);
//printf("ipdst:%s ipsrc:%s\n", ipdst, ipsrc);
ret = read(0, iptmp, sizeof(iptmp));
iptmp[ret - 1] = '\0';
inet_pton(AF_INET, iptmp, &traget.s_addr);
break;
}
send_attack(sfd, ifindex, &traget, &gatWaybuf);
return 0;
}
static int git_transport_push(struct transport *transport, struct ref *remote_refs, int flags)
{
struct git_transport_data *data = transport->data;
struct send_pack_args args;
int ret;
if (!data->got_remote_heads) {
struct ref *tmp_refs;
connect_setup(transport, 1);
get_remote_heads(data->fd[0], NULL, 0, &tmp_refs, REF_NORMAL,
NULL, &data->shallow);
data->got_remote_heads = 1;
}
memset(&args, 0, sizeof(args));
args.send_mirror = !!(flags & TRANSPORT_PUSH_MIRROR);
args.force_update = !!(flags & TRANSPORT_PUSH_FORCE);
args.use_thin_pack = data->options.thin;
args.verbose = (transport->verbose > 0);
args.quiet = (transport->verbose < 0);
args.progress = transport->progress;
args.dry_run = !!(flags & TRANSPORT_PUSH_DRY_RUN);
args.porcelain = !!(flags & TRANSPORT_PUSH_PORCELAIN);
args.atomic = !!(flags & TRANSPORT_PUSH_ATOMIC);
args.push_options = transport->push_options;
args.url = transport->url;
if (flags & TRANSPORT_PUSH_CERT_ALWAYS)
args.push_cert = SEND_PACK_PUSH_CERT_ALWAYS;
else if (flags & TRANSPORT_PUSH_CERT_IF_ASKED)
args.push_cert = SEND_PACK_PUSH_CERT_IF_ASKED;
else
args.push_cert = SEND_PACK_PUSH_CERT_NEVER;
ret = send_pack(&args, data->fd, data->conn, remote_refs,
&data->extra_have);
close(data->fd[1]);
close(data->fd[0]);
ret |= finish_connect(data->conn);
data->conn = NULL;
data->got_remote_heads = 0;
return ret;
}
void catcher(void)
{
struct timeval tv;
gettimeofday(&tv, NULL);
if (start.tv_sec==0)
start = tv;
if (count-- == 0 || (timeout && MS_TDIFF(tv,start) > timeout*1000 + 500))
finish();
if (last.tv_sec==0 || MS_TDIFF(tv,last) > 500) {
send_pack(s, src, dst, &me, &he);
if (count == 0 && unsolicited)
finish();
}
alarm(1);
}
void dir(){
// send command //
allzero(buffer, 1);
send_pack(DIRL, buffer, sock);
/* send port number for data connection to server */
send_data_port();
// make socket and accept server's Data Connection (active)//
makeDataConnection();
fprintf(stderr, "get() : data connection accepted\n");
// recieve file list //
receive_file_list();
fprintf(stdout, "get() : complete file received\n");
// close the data connection //
close(request->serverSocket);
}
void pwd(){
// send command
allzero(buffer, 1);
send_pack(PWD, buffer, sock);
// receive the server's response //
if(recv(sock, packet_str, PACK_SIZE, 0) < 0){
error("recv");
}
parse_packet(packet_str, packet);
// take appropriate action
if(packet.command_code == PWD){
fprintf(stdout, "%s\n", packet.buffer);
strcpy(server_curdir, packet.buffer);
}
else if(packet.command_code == INVALID){
fprintf(stderr, "Not able to retrieve current working directory\n");
}
}
void sendFile(FILE *file_ptr){
int buf_byte = 0, ch = ' ';
do{
ch = fgetc(file_ptr);
if(ch != EOF)
buffer[buf_byte] = ch;
else
buffer[buf_byte] = '\0';
buf_byte++;
if(buf_byte == BUF_SIZE)
buffer[buf_byte] = '\0';
if(buf_byte == BUF_SIZE || ch==EOF){
buf_byte = 0;
// Send response //
send_pack((enum commands)1, packet_str, request->serverSocket);
fprintf(stdout, "sendFile() : file packet contents : %s\n", packet_str);
}
}while(ch != EOF);
}
void mgetw(){
// Send command //
send_pack(MGETW, command.arguments, sock);
fprintf(stdout, "%s\n", packet_str);
/* send port number for data connection to server */
send_data_port();
// make socket and accept server's Data Connection (active)//
makeDataConnection();
fprintf(stderr, "mgetw() : data connection accepted\n");
// recieve file //
receive_mgetw_files();
fprintf(stdout, "mgetw() : files completely received\n");
fflush(stdout);
// close the data connection //
close(request->serverSocket);
//close(sock_data);
}
void cd(){
// Send command //
send_pack(CD, command.arguments, sock);
fprintf(stdout, "cd() : packet_str : %s : packet_str len : %d\n", packet_str, strlen(packet_str));
// receive the server's response //
strncpy(packet_str, "", PACK_SIZE);
if(recv(sock, packet_str, PACK_SIZE, 0) < 0){
error("recv");
}
parse_packet(packet_str, packet);
// take appropriate action
if(packet.command_code == INVALID){
fprintf(stderr, "Not able to change to the specified directory\n");
}
else /*if(packet.command_code == CD)*/{
fprintf(stdout, "%s\n", packet.buffer);
strcpy(server_curdir, packet.buffer);
}
fflush(stdout);
}
/*在新的进程里一直循环执行的函数，实现数据的接收和发送*/
static int echodemo_run()
{
int ret, send_len, recv_len = 0;
char send_packet_buf[PACKET_BUF_SIZE];
char recv_packet_buf[PACKET_BUF_SIZE];
unsigned char send_flag , recv_flag;
while(1)
{
rtdb_get_data_value_by_name("sys_set","send_pack_flag",&send_flag);//查询是否有数据发送
if(send_flag == 1)
{
rtdb_get_data_value_by_name("sys_set","send_pack",send_packet_buf);//复制数据
send_flag = 0;
rtdb_set_data_value_by_name("sys_set","send_pack_flag",&send_flag);
ret = send_pack(send_packet_buf);//数据发送
}
ret = recv_pack(recv_packet_buf, sizeof(recv_packet_buf), &recv_len,100);
#if debug
if(SERIAL_STATUS_TIMEOUT != ret)
rtdb_set_data_value_by_name("test_parm","ret",&ret);
if(recv_len != 0)
rtdb_set_data_value_by_name("test_parm","rec_len",&recv_len);
#endif
serial_flush(serial_id, SERIAL_FLUSH_RX);//清空接收缓存
if(ret == SERIAL_STATUS_OK)//成功接收一帧消息
{
rtdb_set_data_value_by_name("sys_set", "recv_pack", recv_packet_buf);
recv_flag = 1;
rtdb_set_data_value_by_name("sys_set", "recv_pack_flag", &recv_flag);//接收到一帧
debug_printf("recv 1 pack\n");
}
memset(recv_packet_buf , 0 , PACKET_BUF_SIZE);
}
return SERIAL_STATUS_OK;
}
static void catcher(void)
{
unsigned now;
now = MONOTONIC_US();
if (start == 0)
start = now;
if (count == 0 || (timeout_us && (now - start) > timeout_us))
finish();
/* count < 0 means "infinite count" */
if (count > 0)
count--;
if (last == 0 || (now - last) > 500000) {
send_pack(&src, &dst, &me, &he);
if (count == 0 && (option_mask32 & UNSOLICITED))
finish();
}
alarm(1);
}
void mputw(){
strncpy(filename, command.arguments, BUF_SIZE);
// Send command //
strncpy(buffer, "", BUF_SIZE);
send_pack(MPUTW, buffer, sock);
/* send port number for data connection to server */
send_data_port();
// make socket and accept server's Data Connection (active)//
makeDataConnection();
fprintf(stderr, "mputw() : data connection accepted\n");
// recieve file //
send_mputw_files(filename);
fprintf(stdout, "mputw() : files completely sent\n");
fflush(stdout);
// close the data connection //
close(request->serverSocket);
//close(sock_data);
}
int cmd_send_pack(int argc, const char **argv, const char *prefix)
{
int i, nr_refspecs = 0;
const char **refspecs = NULL;
const char *remote_name = NULL;
struct remote *remote = NULL;
const char *dest = NULL;
int fd[2];
struct child_process *conn;
struct sha1_array extra_have = SHA1_ARRAY_INIT;
struct sha1_array shallow = SHA1_ARRAY_INIT;
struct ref *remote_refs, *local_refs;
int ret;
int helper_status = 0;
int send_all = 0;
const char *receivepack = "git-receive-pack";
int flags;
unsigned int reject_reasons;
int progress = -1;
struct push_cas_option cas = {0};
argv++;
for (i = 1; i < argc; i++, argv++) {
const char *arg = *argv;
if (*arg == '-') {
if (starts_with(arg, "--receive-pack=")) {
receivepack = arg + 15;
continue;
}
if (starts_with(arg, "--exec=")) {
receivepack = arg + 7;
continue;
}
if (starts_with(arg, "--remote=")) {
remote_name = arg + 9;
continue;
}
if (!strcmp(arg, "--all")) {
send_all = 1;
continue;
}
if (!strcmp(arg, "--dry-run")) {
args.dry_run = 1;
continue;
}
if (!strcmp(arg, "--mirror")) {
args.send_mirror = 1;
continue;
}
if (!strcmp(arg, "--force")) {
args.force_update = 1;
continue;
}
if (!strcmp(arg, "--quiet")) {
args.quiet = 1;
continue;
}
if (!strcmp(arg, "--verbose")) {
args.verbose = 1;
continue;
}
if (!strcmp(arg, "--progress")) {
progress = 1;
continue;
}
if (!strcmp(arg, "--no-progress")) {
progress = 0;
continue;
}
if (!strcmp(arg, "--thin")) {
args.use_thin_pack = 1;
continue;
}
if (!strcmp(arg, "--stateless-rpc")) {
args.stateless_rpc = 1;
continue;
}
if (!strcmp(arg, "--helper-status")) {
helper_status = 1;
continue;
}
if (!strcmp(arg, "--" CAS_OPT_NAME)) {
if (parse_push_cas_option(&cas, NULL, 0) < 0)
exit(1);
continue;
}
if (!strcmp(arg, "--no-" CAS_OPT_NAME)) {
if (parse_push_cas_option(&cas, NULL, 1) < 0)
exit(1);
continue;
}
if (starts_with(arg, "--" CAS_OPT_NAME "=")) {
if (parse_push_cas_option(&cas,
strchr(arg, '=') + 1, 0) < 0)
exit(1);
continue;
}
usage(send_pack_usage);
}
if (!dest) {
dest = arg;
continue;
}
refspecs = (const char **) argv;
nr_refspecs = argc - i;
break;
}
if (!dest)
usage(send_pack_usage);
/*
* --all and --mirror are incompatible; neither makes sense
* with any refspecs.
*/
if ((refspecs && (send_all || args.send_mirror)) ||
(send_all && args.send_mirror))
usage(send_pack_usage);
if (remote_name) {
remote = remote_get(remote_name);
if (!remote_has_url(remote, dest)) {
die("Destination %s is not a uri for %s",
dest, remote_name);
}
}
if (progress == -1)
progress = !args.quiet && isatty(2);
args.progress = progress;
if (args.stateless_rpc) {
conn = NULL;
fd[0] = 0;
fd[1] = 1;
} else {
conn = git_connect(fd, dest, receivepack,
args.verbose ? CONNECT_VERBOSE : 0);
}
get_remote_heads(fd[0], NULL, 0, &remote_refs, REF_NORMAL,
&extra_have, &shallow);
transport_verify_remote_names(nr_refspecs, refspecs);
local_refs = get_local_heads();
flags = MATCH_REFS_NONE;
if (send_all)
flags |= MATCH_REFS_ALL;
if (args.send_mirror)
flags |= MATCH_REFS_MIRROR;
/* match them up */
if (match_push_refs(local_refs, &remote_refs, nr_refspecs, refspecs, flags))
return -1;
if (!is_empty_cas(&cas))
apply_push_cas(&cas, remote, remote_refs);
set_ref_status_for_push(remote_refs, args.send_mirror,
args.force_update);
ret = send_pack(&args, fd, conn, remote_refs, &extra_have);
if (helper_status)
print_helper_status(remote_refs);
close(fd[1]);
close(fd[0]);
ret |= finish_connect(conn);
if (!helper_status)
transport_print_push_status(dest, remote_refs, args.verbose, 0, &reject_reasons);
if (!args.dry_run && remote) {
struct ref *ref;
for (ref = remote_refs; ref; ref = ref->next)
transport_update_tracking_ref(remote, ref, args.verbose);
}
if (!ret && !transport_refs_pushed(remote_refs))
fprintf(stderr, "Everything up-to-date\n");
return ret;
}
int cmd_send_pack(int argc, const char **argv, const char *prefix)
{
int i, nr_refspecs = 0;
const char **refspecs = NULL;
const char *remote_name = NULL;
struct remote *remote = NULL;
const char *dest = NULL;
int fd[2];
struct child_process *conn;
struct extra_have_objects extra_have;
struct ref *remote_refs, *local_refs;
int ret;
int send_all = 0;
const char *receivepack = "git-receive-pack";
int flags;
argv++;
for (i = 1; i < argc; i++, argv++) {
const char *arg = *argv;
if (*arg == '-') {
if (!prefixcmp(arg, "--receive-pack=")) {
receivepack = arg + 15;
continue;
}
if (!prefixcmp(arg, "--exec=")) {
receivepack = arg + 7;
continue;
}
if (!prefixcmp(arg, "--remote=")) {
remote_name = arg + 9;
continue;
}
if (!strcmp(arg, "--all")) {
send_all = 1;
continue;
}
if (!strcmp(arg, "--dry-run")) {
args.dry_run = 1;
continue;
}
if (!strcmp(arg, "--mirror")) {
args.send_mirror = 1;
continue;
}
if (!strcmp(arg, "--force")) {
args.force_update = 1;
continue;
}
if (!strcmp(arg, "--verbose")) {
args.verbose = 1;
continue;
}
if (!strcmp(arg, "--thin")) {
args.use_thin_pack = 1;
continue;
}
usage(send_pack_usage);
}
if (!dest) {
dest = arg;
continue;
}
refspecs = (const char **) argv;
nr_refspecs = argc - i;
break;
}
if (!dest)
usage(send_pack_usage);
/*
* --all and --mirror are incompatible; neither makes sense
* with any refspecs.
*/
if ((refspecs && (send_all || args.send_mirror)) ||
(send_all && args.send_mirror))
usage(send_pack_usage);
if (remote_name) {
remote = remote_get(remote_name);
if (!remote_has_url(remote, dest)) {
die("Destination %s is not a uri for %s",
dest, remote_name);
}
}
conn = git_connect(fd, dest, receivepack, args.verbose ? CONNECT_VERBOSE : 0);
memset(&extra_have, 0, sizeof(extra_have));
get_remote_heads(fd[0], &remote_refs, 0, NULL, REF_NORMAL,
&extra_have);
verify_remote_names(nr_refspecs, refspecs);
local_refs = get_local_heads();
flags = MATCH_REFS_NONE;
if (send_all)
flags |= MATCH_REFS_ALL;
if (args.send_mirror)
flags |= MATCH_REFS_MIRROR;
/* match them up */
if (match_refs(local_refs, &remote_refs, nr_refspecs, refspecs, flags))
return -1;
ret = send_pack(&args, fd, conn, remote_refs, &extra_have);
close(fd[1]);
close(fd[0]);
ret |= finish_connect(conn);
print_push_status(dest, remote_refs);
if (!args.dry_run && remote) {
struct ref *ref;
for (ref = remote_refs; ref; ref = ref->next)
update_tracking_ref(remote, ref);
}
if (!ret && !refs_pushed(remote_refs))
fprintf(stderr, "Everything up-to-date\n");
return ret;
}
void send_data_port(){
char data_port_str[5];
sprintf(data_port_str, "%d", DATA_PORT);
send_pack(PORT, data_port_str, sock);
}
void sendMultipleFiles(char *file_list_str){
short byte_no = 0, buf_byte = 0, file_no = 0, filename_byte = 0, buffer_byte = 0;
char ch_file = ' ', filename[BUF_SIZE], ch = ' ', ch_filename = ' ';
FILE *file_ptr;
fprintf(stderr, "sendMultipleFiles() : file_list_str : %s\n", file_list_str);
while(byte_no < strlen(file_list_str)){
ch_filename = file_list_str[byte_no++];
//fprintf(stdout, "byte_no : %d\tch_filename : %c\n", byte_no, ch_filename);
if((ch_filename == ' ' && buf_byte && filename[buf_byte - 1] != '\\') || (byte_no == strlen(file_list_str))){
if(byte_no == strlen(file_list_str)){
filename[buf_byte++] = ch_filename;
}
filename[buf_byte++] = '\0';
buf_byte = 0;
fprintf(stdout, "sendMultipleFiles() : filename : %s\n", filename);
for(filename_byte = 0; filename[filename_byte] != '\0'; filename_byte++){
ch = filename[filename_byte];
if(buffer_byte != BUF_SIZE - 1)
buffer[buffer_byte++] = ch;
else{
buffer[buffer_byte] = '\0';
buffer_byte = 0;
fprintf(stdout, "send_mputw_files() : buffer : %s\n", buffer);
send_pack((enum commands)1, buffer, request->serverSocket);
}
}
if(buffer_byte == BUF_SIZE - 1){
buffer[buffer_byte] = '\0';
buffer_byte = 0;
fprintf(stdout, "send_mputw_files() : buffer : %s\n", buffer);
send_pack((enum commands)1, buffer, request->serverSocket);
}
buffer[buffer_byte++] = '\t';
file_ptr = fopen(filename, "r");
if(!file_ptr){
fprintf(stdout, "sendMultipleFiles() : %s : not found\n", filename);
}
else{
fprintf(stdout, "sendMultipleFiles() : %s : started to buffer\n", filename);
ch_file = ' ';
do{
if(buffer_byte != BUF_SIZE - 1){
ch_file = fgetc(file_ptr);
buffer[buffer_byte++] = ch_file;
}
if(buffer_byte == BUF_SIZE - 1){
buffer[buffer_byte] = '\0';
buffer_byte = 0;
fprintf(stdout, "send_mputw_files() : buffer : %s\n", buffer);
send_pack((enum commands)1, buffer, request->serverSocket);
}
}while(ch_file != EOF);
fclose(file_ptr);
}
}
else
filename[buf_byte++] = ch_filename;
}
if(buffer_byte){
buffer[buffer_byte++] = '\0';
fprintf(stdout, "send_mputw_files() : buffer : %s\n", buffer);
send_pack((enum commands)1, buffer, request->serverSocket);
}
fflush(stdout);
}
void Packet::set_source_node(Node* node)
{ //assign the source node
source_node = node;
std::pair<int,int> loc = location(node);
QQuickItem *item = qobject_cast<QQuickItem*>(pac_obj);
item->setProperty("x", loc.first+offset);
item->setProperty("y", loc.second+offset);
QObject::connect(this->pac_obj, SIGNAL(dest_reached(QString)), this->source_node,SLOT(send_pack(QString)),Qt::UniqueConnection);
}
void send_rputdir_files(char *baseDir){
short filename_byte = 0, file_dir = 1;
char filename[BUF_SIZE], ch_file = ' ', ch = ' ';
struct dirent *dirp;
struct stat isdir;
FILE *file_ptr;
DIR *dp = opendir(baseDir);
while((dirp = readdir(dp)) != NULL){
if(strcmp(dirp->d_name, "..") != 0 && strcmp(dirp->d_name, ".") != 0){
strncpy(filename, baseDir, BUF_SIZE);
strcat(filename, "/");
strcat(filename, dirp->d_name);
file_dir = !stat(filename, &isdir) && (isdir.st_mode & S_IFDIR) ? 1 : 0;
fprintf(stdout, "send_rputdir_files() : filename : %s\n", filename);
for(filename_byte = 0; filename[filename_byte] != '\0'; filename_byte++){
ch = filename[filename_byte];
if(buffer_byte != BUF_SIZE - 1)
buffer[buffer_byte++] = ch;
else{
buffer[buffer_byte] = '\0';
buffer_byte = 0;
fprintf(stdout, "send_rputdir_files() : buffer : %s\n", buffer);
send_pack((enum commands)1, buffer, request->serverSocket);
}
}
//fprintf(stdout, "send_rputdir_files() : buffer : %s\n", buffer);
if(buffer_byte == BUF_SIZE - 1){
buffer[buffer_byte] = '\0';
buffer_byte = 0;
fprintf(stdout, "send_rputdir_files() : buffer : %s\n", buffer);
send_pack((enum commands)1, buffer, request->serverSocket);
}
buffer[buffer_byte++] = '\t';
if(buffer_byte == BUF_SIZE - 1){
buffer[buffer_byte] = '\0';
buffer_byte = 0;
fprintf(stdout, "send_rputdir_files() : buffer : %s\n", buffer);
send_pack((enum commands)1, buffer, request->serverSocket);
}
buffer[buffer_byte++] = (char)(file_dir + '0');
if(!file_dir){
file_ptr = fopen(filename, "r");
ch_file = ' ';
do{
if(buffer_byte != BUF_SIZE - 1){
ch_file = fgetc(file_ptr);
buffer[buffer_byte++] = ch_file;
}
if(buffer_byte == BUF_SIZE - 1){
buffer[buffer_byte] = '\0';
buffer_byte = 0;
fprintf(stdout, "send_rputdir_files() : buffer : %s\n", buffer);
send_pack((enum commands)1, buffer, request->serverSocket);
}
}while(ch_file != EOF);
fclose(file_ptr);
}
else{
send_rputdir_files(filename);
}
}
}
buffer[buffer_byte] = '\0';
fprintf(stdout, "send_rputdir_files() : buffer : %s\n", buffer);
send_pack((enum commands)1, buffer, request->serverSocket);
closedir(dp);
}
