int upload(char *filename){
// For simple, I use 40B hex string instead
unsigned char fp[20];
char hash[41];
int res = 0;
char fp_filename[MAXLINE];
// 1. inquiry the server if the file is duplicated by fingerprint (a RTT)
res = SHA1File(filename, fp);
if(res){
printf("Get file sha1 hash failed.\n");
return -1;
}
digestToHash(fp, hash); // rabin.h
fp_filename[0] = '\0';
strcat(fp_filename, hash);
strcat(fp_filename, filename);
res = isExistsFile(fp_filename);
if(!res){ // file existed , stop
// 2. transfer not duplicated chunks to server
transfer_file(fp_filename, filename);
}
return 0;
}
static void check_magic(files_struct *fsp,connection_struct *conn)
{
if (!*lp_magicscript(SNUM(conn)))
return;
DEBUG(5,("checking magic for %s\n",fsp->fsp_name));
{
char *p;
if (!(p = strrchr_m(fsp->fsp_name,'/')))
p = fsp->fsp_name;
else
p++;
if (!strequal(lp_magicscript(SNUM(conn)),p))
return;
}
{
int ret;
pstring magic_output;
pstring fname;
SMB_STRUCT_STAT st;
int tmp_fd, outfd;
pstrcpy(fname,fsp->fsp_name);
if (*lp_magicoutput(SNUM(conn)))
pstrcpy(magic_output,lp_magicoutput(SNUM(conn)));
else
slprintf(magic_output,sizeof(fname)-1, "%s.out",fname);
chmod(fname,0755);
ret = smbrun(fname,&tmp_fd);
DEBUG(3,("Invoking magic command %s gave %d\n",fname,ret));
unlink(fname);
if (ret != 0 || tmp_fd == -1) {
if (tmp_fd != -1)
close(tmp_fd);
return;
}
outfd = open(magic_output, O_CREAT|O_EXCL|O_RDWR, 0600);
if (outfd == -1) {
close(tmp_fd);
return;
}
if (sys_fstat(tmp_fd,&st) == -1) {
close(tmp_fd);
close(outfd);
return;
}
transfer_file(tmp_fd,outfd,(SMB_OFF_T)st.st_size);
close(tmp_fd);
close(outfd);
}
}
int upload(char *filename){
// For simple, I use 40B hex string instead
unsigned char fp[20];
char hash[41];
int res = 0;
char fp_filename[MAXLINE];
// 1. inquiry the server if the file is duplicated by fingerprint (a RTT)
printf("upload:filename=%s\n", filename);
res = SHA1File(filename, fp);
if(res){
printf("Get file sha1 hash failed.\n");
return -1;
}
digestToHash(fp, hash); // rabin.h
fp_filename[0] = '\0';
strcat(fp_filename, hash);
strcat(fp_filename, filename);
res = isExistsFile(fp_filename, filename);
switch(res){
case 1:
return 0;
break;
case -1:
transfer_file(fp_filename, filename, 1);
break;
case -2:
transfer_file(fp_filename, filename, 0);
break;
default:
printf("ERROR!!!\n");
}
// sleep(1);
// file_count ++;
// if(file_count % 10 == 0)
// sleep(10);
return 0;
}
void handle_get_activity()
{
uint32_t size = 0;
char* fn = get_data_file(&size);
if (fn == NULL)
{
log_info("handle_get_activity() no valid data\n");
return;
}
log_info("handle_get_activity() return %s\n", fn);
transfer_file(fn);
}
static void ldif_write_output(enum netr_SamDatabaseID database_id,
struct samsync_ldif_context *l)
{
/* Write ldif data to the user's file */
if (database_id == SAM_DATABASE_DOMAIN) {
fprintf(l->ldif_file,
"# SAM_DATABASE_DOMAIN: ADD ENTITIES\n");
fprintf(l->ldif_file,
"# =================================\n\n");
fflush(l->ldif_file);
} else if (database_id == SAM_DATABASE_BUILTIN) {
fprintf(l->ldif_file,
"# SAM_DATABASE_BUILTIN: ADD ENTITIES\n");
fprintf(l->ldif_file,
"# ==================================\n\n");
fflush(l->ldif_file);
}
fseek(l->add_file, 0, SEEK_SET);
transfer_file(fileno(l->add_file), fileno(l->ldif_file), (size_t) -1);
if (database_id == SAM_DATABASE_DOMAIN) {
fprintf(l->ldif_file,
"# SAM_DATABASE_DOMAIN: MODIFY ENTITIES\n");
fprintf(l->ldif_file,
"# ====================================\n\n");
fflush(l->ldif_file);
} else if (database_id == SAM_DATABASE_BUILTIN) {
fprintf(l->ldif_file,
"# SAM_DATABASE_BUILTIN: MODIFY ENTITIES\n");
fprintf(l->ldif_file,
"# =====================================\n\n");
fflush(l->ldif_file);
}
fseek(l->mod_file, 0, SEEK_SET);
transfer_file(fileno(l->mod_file), fileno(l->ldif_file), (size_t) -1);
}
int
main(int argc, char **argv)
{
int sockfd, sockfd2;
struct sockaddr_in servaddr;
if (argc != 2)
err_quit("usage: tcpcli <IPaddress>");
// 1. inquiry the server if the file is duplicated by fingerprint (a RTT)
sockfd = Socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(SERV_PORT+1); //
Inet_pton(AF_INET, argv[1], &servaddr.sin_addr);
Connect(sockfd, (SA *) &servaddr, sizeof(servaddr));
inquiry_by_fp(sockfd, "not_used"); /* do it all */
close(sockfd); // yes close sockfd
// 2. transfer not duplicated chunks to server
sockfd2 = Socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(SERV_PORT); //
Inet_pton(AF_INET, argv[1], &servaddr.sin_addr);
Connect(sockfd2, (SA *) &servaddr, sizeof(servaddr));
transfer_file(sockfd2, 0);
close(sockfd2);
exit(0);
}
static NTSTATUS check_magic(struct files_struct *fsp)
{
int ret;
const char *magic_output = NULL;
SMB_STRUCT_STAT st;
int tmp_fd, outfd;
TALLOC_CTX *ctx = NULL;
const char *p;
struct connection_struct *conn = fsp->conn;
char *fname = NULL;
NTSTATUS status;
if (!*lp_magic_script(talloc_tos(), SNUM(conn))) {
return NT_STATUS_OK;
}
DEBUG(5,("checking magic for %s\n", fsp_str_dbg(fsp)));
ctx = talloc_stackframe();
fname = fsp->fsp_name->base_name;
if (!(p = strrchr_m(fname,'/'))) {
p = fname;
} else {
p++;
}
if (!strequal(lp_magic_script(talloc_tos(), SNUM(conn)),p)) {
status = NT_STATUS_OK;
goto out;
}
if (*lp_magic_output(talloc_tos(), SNUM(conn))) {
magic_output = lp_magic_output(talloc_tos(), SNUM(conn));
} else {
magic_output = talloc_asprintf(ctx,
"%s.out",
fname);
}
if (!magic_output) {
status = NT_STATUS_NO_MEMORY;
goto out;
}
/* Ensure we don't depend on user's PATH. */
p = talloc_asprintf(ctx, "./%s", fname);
if (!p) {
status = NT_STATUS_NO_MEMORY;
goto out;
}
if (chmod(fname, 0755) == -1) {
status = map_nt_error_from_unix(errno);
goto out;
}
ret = smbrun(p,&tmp_fd);
DEBUG(3,("Invoking magic command %s gave %d\n",
p,ret));
unlink(fname);
if (ret != 0 || tmp_fd == -1) {
if (tmp_fd != -1) {
close(tmp_fd);
}
status = NT_STATUS_UNSUCCESSFUL;
goto out;
}
outfd = open(magic_output, O_CREAT|O_EXCL|O_RDWR, 0600);
if (outfd == -1) {
int err = errno;
close(tmp_fd);
status = map_nt_error_from_unix(err);
goto out;
}
if (sys_fstat(tmp_fd, &st, false) == -1) {
int err = errno;
close(tmp_fd);
close(outfd);
status = map_nt_error_from_unix(err);
goto out;
}
if (transfer_file(tmp_fd,outfd,(off_t)st.st_ex_size) == (off_t)-1) {
int err = errno;
close(tmp_fd);
close(outfd);
status = map_nt_error_from_unix(err);
goto out;
}
close(tmp_fd);
if (close(outfd) == -1) {
status = map_nt_error_from_unix(errno);
goto out;
}
status = NT_STATUS_OK;
out:
TALLOC_FREE(ctx);
return status;
}
int main(int argc, char *argv[])
{
int ret = 0;
int fd;
parse_opts(argc, argv);
fd = open(device, O_RDWR);
if (fd < 0)
pabort("can't open device");
/*
* spi mode
*/
ret = ioctl(fd, SPI_IOC_WR_MODE32, &mode);
if (ret == -1)
pabort("can't set spi mode");
ret = ioctl(fd, SPI_IOC_RD_MODE32, &mode);
if (ret == -1)
pabort("can't get spi mode");
/*
* bits per word
*/
ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits);
if (ret == -1)
pabort("can't set bits per word");
ret = ioctl(fd, SPI_IOC_RD_BITS_PER_WORD, &bits);
if (ret == -1)
pabort("can't get bits per word");
/*
* max speed hz
*/
ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);
if (ret == -1)
pabort("can't set max speed hz");
ret = ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &speed);
if (ret == -1)
pabort("can't get max speed hz");
printf("spi mode: 0x%x\n", mode);
printf("bits per word: %d\n", bits);
printf("max speed: %d Hz (%d KHz)\n", speed, speed/1000);
if (input_tx && input_file)
pabort("only one of -p and --input may be selected");
if (input_tx)
transfer_escaped_string(fd, input_tx);
else if (input_file)
transfer_file(fd, input_file);
else
transfer(fd, default_tx, default_rx, sizeof(default_tx));
close(fd);
return ret;
}
static int copy_reg(const char *source, const char *dest)
{
SMB_STRUCT_STAT source_stats;
int saved_errno;
int ifd = -1;
int ofd = -1;
if (sys_lstat (source, &source_stats) == -1)
return -1;
if (!S_ISREG (source_stats.st_mode))
return -1;
if((ifd = sys_open (source, O_RDONLY, 0)) < 0)
return -1;
if (unlink (dest) && errno != ENOENT)
return -1;
#ifdef O_NOFOLLOW
if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC | O_NOFOLLOW, 0600)) < 0 )
#else
if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC , 0600)) < 0 )
#endif
goto err;
if (transfer_file(ifd, ofd, (size_t)-1) == -1)
goto err;
/*
* Try to preserve ownership. For non-root it might fail, but that's ok.
* But root probably wants to know, e.g. if NFS disallows it.
*/
#ifdef HAVE_FCHOWN
if ((fchown(ofd, source_stats.st_uid, source_stats.st_gid) == -1) && (errno != EPERM))
#else
if ((chown(dest, source_stats.st_uid, source_stats.st_gid) == -1) && (errno != EPERM))
#endif
goto err;
/*
* fchown turns off set[ug]id bits for non-root,
* so do the chmod last.
*/
#if defined(HAVE_FCHMOD)
if (fchmod (ofd, source_stats.st_mode & 07777))
#else
if (chmod (dest, source_stats.st_mode & 07777))
#endif
goto err;
if (close (ifd) == -1)
goto err;
if (close (ofd) == -1)
return -1;
/* Try to copy the old file's modtime and access time. */
{
struct utimbuf tv;
tv.actime = source_stats.st_atime;
tv.modtime = source_stats.st_mtime;
utime(dest, &tv);
}
if (unlink (source) == -1)
return -1;
return 0;
err:
saved_errno = errno;
if (ifd != -1)
close(ifd);
if (ofd != -1)
close(ofd);
errno = saved_errno;
return -1;
}
void handle_get_file(char* name)
{
log_info("handle_get_file(%s)\n", name);
transfer_file(name);
}
int main(int argc, char *argv[])
{
int ret = 0;
int fd;
parse_opts(argc, argv);
fd = open(device, O_RDWR);
if (fd < 0)
pabort("can't open device");
/*
* spi mode
*/
ret = ioctl(fd, SPI_IOC_WR_MODE32, &mode);
if (ret == -1)
pabort("can't set spi mode");
ret = ioctl(fd, SPI_IOC_RD_MODE32, &mode);
if (ret == -1)
pabort("can't get spi mode");
/*
* bits per word
*/
ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits);
if (ret == -1)
pabort("can't set bits per word");
ret = ioctl(fd, SPI_IOC_RD_BITS_PER_WORD, &bits);
if (ret == -1)
pabort("can't get bits per word");
/*
* max speed hz
*/
ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);
if (ret == -1)
pabort("can't set max speed hz");
ret = ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &speed);
if (ret == -1)
pabort("can't get max speed hz");
printf("spi mode: 0x%x\n", mode);
printf("bits per word: %d\n", bits);
printf("max speed: %d Hz (%d KHz)\n", speed, speed/1000);
if (input_tx && input_file)
pabort("only one of -p and --input may be selected");
if (input_tx)
transfer_escaped_string(fd, input_tx);
else if (input_file)
transfer_file(fd, input_file);
else if (transfer_size) {
struct timespec last_stat;
clock_gettime(CLOCK_MONOTONIC, &last_stat);
while (iterations-- > 0) {
struct timespec current;
transfer_buf(fd, transfer_size);
clock_gettime(CLOCK_MONOTONIC, ¤t);
if (current.tv_sec - last_stat.tv_sec > interval) {
show_transfer_rate();
last_stat = current;
}
}
printf("total: tx %.1fKB, rx %.1fKB\n",
_write_count/1024.0, _read_count/1024.0);
} else
transfer(fd, default_tx, default_rx, sizeof(default_tx));
close(fd);
return ret;
}
static int retrieve_url(AbstractClient *const client, const std::wstring &url_string, const http_verb_t &http_verb, const URL &url, const std::wstring &post_data, const std::wstring &referrer, const std::wstring &outFileName, const bool &set_ftime, const bool &update_mode, const bool &alert, const bool &keep_failed)
{
//Initialize the post data string
const std::string post_data_encoded = post_data.empty() ? std::string() : ((post_data.compare(L"-") != 0) ? URL::urlEncode(Utils::wide_str_to_utf8(post_data)) : URL::urlEncode(stdin_get_line()));
//Detect filestamp of existing file
const uint64_t timestamp_existing = update_mode ? Utils::get_file_time(outFileName) : AbstractClient::TIME_UNKNOWN;
if(update_mode && (timestamp_existing == AbstractClient::TIME_UNKNOWN))
{
std::wcerr << L"WARNING: Local file does not exist yet, going to download unconditionally!\n" << std::endl;
}
//Create the HTTPS connection/request
std::wcerr << L"Connecting to " << url.getHostName() << L':' << url.getPortNo() << L", please wait..." << std::endl;
std::unique_ptr<ConnectorThread> connector_thread (new ConnectorThread(client, http_verb, url, post_data_encoded, referrer, timestamp_existing));
if(!connector_thread->start())
{
TRIGGER_SYSTEM_SOUND(alert, false);
std::wcerr << L"ERROR: Failed to start the file connector thread!\n" << std::endl;
return EXIT_FAILURE;
}
//Wait for connection
while(!connector_thread->join(Zero::g_sigUserAbort))
{
//Check for user abort
if(ABORTED_BY_USER)
{
std::wcerr << L"--> Aborting!\n"<< std::endl;
connector_thread->stop(1250, true);
std::wcerr << L"SIGINT: Operation aborted by the user !!!\n" << std::endl;
return EXIT_FAILURE;
}
}
//Add extra space
std::wcerr << std::endl;
//Check thread result
const uint32_t thread_result = connector_thread->get_result();
if(thread_result != ConnectorThread::CONNECTION_COMPLETE)
{
const std::wstring error_text = connector_thread->get_error_text();
switch(thread_result)
{
case ConnectorThread::CONNECTION_ERR_INET:
if(!error_text.empty())
{
std::wcerr << error_text << L'\n' << std::endl;
}
std::wcerr << "ERROR: Connection could not be established!\n" << std::endl;
break;
case ConnectorThread::CONNECTION_ERR_ABRT:
std::wcerr << L"ERROR: The operation has been aborted !!!\n" << std::endl;
break;
default:
std::wcerr << L"ERROR: The operation failed for an unknwon reason!\n" << std::endl;
break;
}
TRIGGER_SYSTEM_SOUND(alert, false);
return EXIT_FAILURE;
}
//Check for user abort
if(ABORTED_BY_USER)
{
std::wcerr << L"SIGINT: Operation aborted by the user !!!\n" << std::endl;
return EXIT_FAILURE;
}
//Initialize local variables
bool success;
uint32_t status_code;
std::wstring content_type, content_encd;
uint64_t file_size, timestamp;
//Query result information
if(!client->result(success, status_code, file_size, timestamp, content_type, content_encd))
{
TRIGGER_SYSTEM_SOUND(alert, false);
const std::wstring error_text = client->get_error_text();
if(!error_text.empty())
{
std::wcerr << error_text << L'\n' << std::endl;
}
std::wcerr << "ERROR: Failed to query the response status!\n" << std::endl;
return EXIT_FAILURE;
}
//Skip download this time?
if(update_mode && (status_code == 304))
{
TRIGGER_SYSTEM_SOUND(alert, true);
std::wcerr << L"SKIPPED: Server currently does *not* provide a newer version of the file." << std::endl;
std::wcerr << L" Version created at '" << Utils::timestamp_to_str(timestamp_existing) << L"' was retained.\n" << std::endl;
return EXIT_SUCCESS;
}
//Print some status information
std::wcerr << L"HTTP response successfully received from server:\n";
print_response_info(status_code, file_size, timestamp, content_type, content_encd);
//Request successful?
if(!success)
{
TRIGGER_SYSTEM_SOUND(alert, false);
std::wcerr << "ERROR: The server failed to handle this request! [Status " << status_code << "]\n" << std::endl;
return EXIT_FAILURE;
}
//Check for user abort
if(ABORTED_BY_USER)
{
std::wcerr << L"SIGINT: Operation aborted by the user !!!\n" << std::endl;
return EXIT_FAILURE;
}
return transfer_file(client, url_string, file_size, (set_ftime ? timestamp : 0), outFileName, alert, keep_failed);
}
static void check_magic(struct files_struct *fsp)
{
int ret;
const char *magic_output = NULL;
SMB_STRUCT_STAT st;
int tmp_fd, outfd;
TALLOC_CTX *ctx = NULL;
const char *p;
struct connection_struct *conn = fsp->conn;
if (!*lp_magicscript(SNUM(conn))) {
return;
}
DEBUG(5,("checking magic for %s\n",fsp->fsp_name));
if (!(p = strrchr_m(fsp->fsp_name,'/'))) {
p = fsp->fsp_name;
} else {
p++;
}
if (!strequal(lp_magicscript(SNUM(conn)),p)) {
return;
}
ctx = talloc_stackframe();
if (*lp_magicoutput(SNUM(conn))) {
magic_output = lp_magicoutput(SNUM(conn));
} else {
magic_output = talloc_asprintf(ctx,
"%s.out",
fsp->fsp_name);
}
if (!magic_output) {
TALLOC_FREE(ctx);
return;
}
/* Ensure we don't depend on user's PATH. */
p = talloc_asprintf(ctx, "./%s", fsp->fsp_name);
if (!p) {
TALLOC_FREE(ctx);
return;
}
if (chmod(fsp->fsp_name,0755) == -1) {
TALLOC_FREE(ctx);
return;
}
ret = smbrun(p,&tmp_fd);
DEBUG(3,("Invoking magic command %s gave %d\n",
p,ret));
unlink(fsp->fsp_name);
if (ret != 0 || tmp_fd == -1) {
if (tmp_fd != -1) {
close(tmp_fd);
}
TALLOC_FREE(ctx);
return;
}
outfd = open(magic_output, O_CREAT|O_EXCL|O_RDWR, 0600);
if (outfd == -1) {
close(tmp_fd);
TALLOC_FREE(ctx);
return;
}
if (sys_fstat(tmp_fd,&st) == -1) {
close(tmp_fd);
close(outfd);
return;
}
#ifdef AVM_VERY_SMALL
AVM_VERY_SMALL_LOG
#else
transfer_file(tmp_fd,outfd,(SMB_OFF_T)st.st_size);
#endif
close(tmp_fd);
close(outfd);
TALLOC_FREE(ctx);
}
int main(int argc, char *argv[]){
ts.tv_sec = 100 / 1000;
ts.tv_nsec = (1 % 1000) * 1000000;
int socket_fd, n;
char packaged[PACKET_SIZE];
char buffer[PACKET_SIZE-5];
//not given hostname and port
if(argc <3){
fprintf(stderr, "usage %s hostname port\n", argv[0]);
exit(0);
}
//init socket
socket_fd = socket(AF_INET, SOCK_STREAM, 0);
if(socket_fd < 0){
perror("Error opening socket");
exit(1);
}
struct addrinfo hints, *servinfo, *p;
int rv;
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC; // use AF_INET6 to force IPv6
hints.ai_socktype = SOCK_STREAM;
if ((rv = getaddrinfo(argv[1], argv[2], &hints, &servinfo)) != 0)
{
fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
exit(1);
}
// loop through all the results and connect to the first we can
for(p = servinfo; p != NULL; p = p->ai_next)
{
if ((socket_fd = socket(p->ai_family, p->ai_socktype,
p->ai_protocol)) == -1)
{
perror("socket");
continue;
}
if (connect(socket_fd, p->ai_addr, p->ai_addrlen) == -1)
{
close(socket_fd);
//perror("connect");
continue;
}
break; // if we get here, we must have connected successfully
}
// Identifying Connect command
printf("Please enter your nickname: ");
//create message for server
bzero(packaged, PACKET_SIZE-1);
bzero(buffer, PACKET_SIZE-5);
fgets(buffer, PACKET_SIZE-5, stdin);
buffer[strcspn(buffer, "\r\n")] = 0; // Trim newlines
sprintf(packaged, "/CONN");
strcat(packaged, buffer);
//send message to server
n = write(socket_fd, packaged, strlen(packaged));
if(n < 0)
{ perror("Error identifying to server"); exit(1); }
pthread_t reader_thread;
if(pthread_create(&reader_thread, NULL, read_chat, &socket_fd)){
fprintf(stderr, "Error creating reader thread\n");
exit(1);
}
printf("Please enter your messages: ");
while(1){
//create message for server
bzero(packaged, PACKET_SIZE-1);
bzero(buffer, PACKET_SIZE-5);
fgets(buffer, PACKET_SIZE-6, stdin);
buffer[strcspn(buffer, "\r\n")] = 0; // Trim newlines
//sprintf(packaged, "%04d", friend_fd);
// Check if file-transfer has started.
if(strstr(buffer, "/FILE") == buffer)
{
if(friend_fd == 0)
{
printf("Cannot send file while in queue.\n");
continue;
}
buffer[strcspn(buffer, "\r\n")] = 0; // Trim newlines
char filename [PACKET_SIZE-12];
memcpy(filename, &buffer[6], PACKET_SIZE-12);
int size;
struct stat st;
stat(filename, &st);
size = st.st_size;
if(size > SIZE_FILE_MAX)
{
printf("File size exceeded.");
continue;
}
strcat(packaged, "/FILE/");
strcat(packaged, filename);
FILE *fp;
fp = fopen(filename, "rb");
if(fp == NULL)
{
perror("Error opening file");
}
else
{
//send message to server
n = write(socket_fd, packaged, strlen(packaged));
nanosleep(&ts, NULL);
if(n < 0)
{ perror("Error writing to server"); continue; }
transfer_file(socket_fd, filename);
}
}
// Majority case
else
{
//strcat(packaged, buffer);
//send message to server
n = write(socket_fd, buffer, strlen(buffer));
nanosleep(&ts, NULL);
if(n < 0)
{ perror("Error writing to server"); exit(1); }
}
}
close(socket_fd);
}
// get request from client socket
void parseClientRequest(player p, char * buffer) {
// socket closed
if(readline(p->fd, buffer, MAXBUF-1) == 0)
removeClient(p);
else if(strlen(buffer) > 3 && buffer[3] == '#') { // new message
#ifdef DEBUG
printf("\r[DEBUG] : %s\n", buffer);
#endif
buffer[3] = 0;
// broadcast message
if(strcmp(buffer, CMD_MESSAGE) == 0)
broadcastMessage(p, buffer);
// broadcast action
else if(strcmp(buffer, CMD_ACTION) == 0)
broadcastMessage(p, buffer);
// bind to a game
else if(strlen(buffer+4) > 6 && buffer[9] == '#' && strcmp(buffer, CMD_BIND) == 0)
bindToGame(p, buffer);
// create a game
else if(strlen(buffer+4) > 6 && buffer[9] == '#' && strcmp(buffer, CMD_CREATE_GAME) == 0)
createGame(p, buffer);
// list existing games
else if(strcmp(buffer, CMD_LIST) == 0)
listGames(p);
// Get available id to creage a game
else if(strcmp(buffer, CMD_CREATE) == 0)
getAvailableId(p);
// Create new socket to send a file
else if(strlen(buffer+4) > 7 && buffer[10] == '#' && strcmp(buffer, CMD_FILE) == 0)
transfer_file(p, buffer);
// Register as a Game Master
else if(strcmp(buffer, CMD_REGISTER_GM) == 0)
register_game_master(p);
// Send a message to game master
else if(strcmp(buffer, CMD_SEND_GM) == 0)
send_to_game_master(p, buffer);
// Send a message to a specific player
else if(strcmp(buffer, CMD_SEND_TO_PLAYER) == 0)
send_to_player(p, buffer);
else
senderror(p->fd, NULL, ERR_NOT_RECOGNIZED);
}
else {
#ifdef DEBUG
printf("\r[DEBUG] : %s\n", buffer);
#endif
senderror(p->fd, NULL, ERR_NOT_RECOGNIZED);
}
}
static int copy_reg(const char *source, const char *dest)
{
SMB_STRUCT_STAT source_stats;
int saved_errno;
int ifd = -1;
int ofd = -1;
if (sys_lstat(source, &source_stats, false) == -1)
return -1;
if (!S_ISREG (source_stats.st_ex_mode))
return -1;
if (source_stats.st_ex_size > module_sizelimit) {
DEBUG(5,
("%s: size of %s larger than sizelimit (%lld > %lld), rename prohititted\n",
MODULE, source,
(long long)source_stats.st_ex_size,
(long long)module_sizelimit));
return -1;
}
if((ifd = open (source, O_RDONLY, 0)) < 0)
return -1;
if (unlink (dest) && errno != ENOENT) {
close(ifd);
return -1;
}
#ifdef O_NOFOLLOW
if((ofd = open (dest, O_WRONLY | O_CREAT | O_TRUNC | O_NOFOLLOW, 0600)) < 0 )
#else
if((ofd = open (dest, O_WRONLY | O_CREAT | O_TRUNC , 0600)) < 0 )
#endif
goto err;
if (transfer_file(ifd, ofd, source_stats.st_ex_size) == -1)
goto err;
/*
* Try to preserve ownership. For non-root it might fail, but that's ok.
* But root probably wants to know, e.g. if NFS disallows it.
*/
#ifdef HAVE_FCHOWN
if ((fchown(ofd, source_stats.st_ex_uid, source_stats.st_ex_gid) == -1) && (errno != EPERM))
#else
if ((chown(dest, source_stats.st_ex_uid, source_stats.st_ex_gid) == -1) && (errno != EPERM))
#endif
goto err;
/*
* fchown turns off set[ug]id bits for non-root,
* so do the chmod last.
*/
#if defined(HAVE_FCHMOD)
if ((fchmod (ofd, source_stats.st_ex_mode & 07777) == -1) &&
(errno != EPERM))
#else
if ((chmod (dest, source_stats.st_ex_mode & 07777) == -1) &&
(errno != EPERM))
#endif
goto err;
if (close (ifd) == -1)
goto err;
if (close (ofd) == -1)
return -1;
/* Try to copy the old file's modtime and access time. */
#if defined(HAVE_UTIMENSAT)
{
struct timespec ts[2];
ts[0] = source_stats.st_ex_atime;
ts[1] = source_stats.st_ex_mtime;
utimensat(AT_FDCWD, dest, ts, AT_SYMLINK_NOFOLLOW);
}
#elif defined(HAVE_UTIMES)
{
struct timeval tv[2];
tv[0] = convert_timespec_to_timeval(source_stats.st_ex_atime);
tv[1] = convert_timespec_to_timeval(source_stats.st_ex_mtime);
#ifdef HAVE_LUTIMES
lutimes(dest, tv);
#else
utimes(dest, tv);
#endif
}
#elif defined(HAVE_UTIME)
{
struct utimbuf tv;
tv.actime = convert_timespec_to_time_t(source_stats.st_ex_atime);
tv.modtime = convert_timespec_to_time_t(source_stats.st_ex_mtime);
utime(dest, &tv);
}
#endif
if (unlink (source) == -1)
return -1;
return 0;
err:
saved_errno = errno;
if (ifd != -1)
close(ifd);
if (ofd != -1)
close(ofd);
errno = saved_errno;
return -1;
}
