static void Serverlist_Sort (void)
{
int i;
int remap = 0;
char addr[32];
int (*comparefunc)(const void *, const void *) = NULL;
switch((int)Cvar_Get("serverlist_order","0",0)->value)
{
case 1:
comparefunc = &Serverlist_SortCompare_Name;
break;
case 2:
comparefunc = &Serverlist_SortCompare_Ping;
break;
case 3:
comparefunc = &Serverlist_SortCompare_Mapname;
break;
case 4:
comparefunc = &Serverlist_SortCompare_Players;
break;
default:
comparefunc = &Serverlist_SortCompare;
}
qsort(m_serverlist.server, m_serverlist.numservers, sizeof(m_serverlist.server[0]), comparefunc);
// viciouz - apparently the following doesn't work for alphabetical sorting. how odd.
// anyway, as it's only running one frame the small efficiency saving isn't really necessary.
// for (i = 0; i < m_serverlist.nummapped; ++i)
for (i = 0; i < m_serverlist.numservers; ++i)
{
if (m_serverlist.server[i].remap >= 0)
{
if (remap < m_serverlist.nummapped) // probably unnecessary to check, but just in case
{
NetAdrToString(m_serverlist.server[i].adr, addr, sizeof(addr));
m_serverlist.server[i].remap = remap;
Z_Free(m_serverlist.ips[remap]);
m_serverlist.ips[remap] = text_copy(addr);
Z_Free(m_serverlist.info[remap]);
m_serverlist.info[remap] = text_copy(format_info_from_serverlist_server(&m_serverlist.server[i]));
++remap;
}
}
}
}
static Object *
state_copy(State *state)
{
int i;
State *newstate;
Element *elem, *newelem;
Object *newobj;
elem = &state->element;
newstate = g_malloc(sizeof(State));
newelem = &newstate->element;
newobj = (Object *) newstate;
element_copy(elem, newelem);
newstate->text = text_copy(state->text);
for (i=0;i<8;i++) {
newobj->connections[i] = &newstate->connections[i];
newstate->connections[i].object = newobj;
newstate->connections[i].connected = NULL;
newstate->connections[i].pos = state->connections[i].pos;
newstate->connections[i].last_pos = state->connections[i].last_pos;
}
newstate->state_type = state->state_type;
state_update_data(newstate);
return (Object *)newstate;
}
static int biniku_put(FILE *fi, FILE *fo) {
uint a, i, n, p = 0, x = 0; void *r[2] = { 0, 0 };
READ(&n, 4); fwrite(&n, 1, 4, fo);
for(i = 0; i < n; i++) {
READ(&a, 4); fwrite(&a, 1, 4, fo);
}
n = n * 4 + 4;
for(;;) {
if(!x) x = text_num();
// printf("replace %08X\n", x + n);
while(p != x) {
if((a = fgetc(fi)) == EOF) goto end; p++; fputc(a, fo);
}
x = text_copy(fo);
do { if((a = fgetc(fi)) == EOF) goto end; p++; } while(a);
fputc(0, fo);
reloc_add(r, p, ftell(fo) - p - n);
}
end: if(r[0]) {
biniku_fix(fi, fo, r[1]);
blk_destroy(r[0]);
}
return 0;
}
static DiaObject *
flow_copy(Flow *flow)
{
Flow *newflow;
Connection *conn, *newconn;
DiaObject *newobj;
conn = &flow->connection;
newflow = g_malloc0(sizeof(Flow));
newconn = &newflow->connection;
newobj = &newconn->object;
connection_copy(conn, newconn);
newflow->text_handle = flow->text_handle;
newflow->text_handle.connected_to = NULL;
newobj->handles[2] = &newflow->text_handle;
newflow->textpos = flow->textpos;
newflow->text = text_copy(flow->text);
newflow->type = flow->type;
flow_update_data(newflow);
return &newflow->connection.object;
}
int cavan_inotify_register_watch(struct cavan_inotify_descriptor *desc, const char *pathname, uint32_t mask, void *data)
{
int wd;
struct cavan_inotify_watch *p;
if (desc->watch_count >= NELEM(desc->watchs))
{
error_msg("Too match watch");
return -EFAULT;
}
if (pathname == NULL || *pathname == 0)
{
error_msg("pathname == NULL || *pathname == 0");
return -EINVAL;
}
wd = inotify_add_watch(desc->fd, pathname, mask);
if (wd < 0)
{
print_error("inotify_add_watch");
return wd;
}
for (p = desc->watchs; p->wd >= 0; p++);
p->wd = wd;
p->data = data;
text_copy(p->pathname, pathname);
desc->watch_count++;
pr_green_info("Add watch: %s", pathname);
return 0;
}
static Object *
smallpackage_copy(SmallPackage *pkg)
{
int i;
SmallPackage *newpkg;
Element *elem, *newelem;
Object *newobj;
elem = &pkg->element;
newpkg = g_malloc(sizeof(SmallPackage));
newelem = &newpkg->element;
newobj = (Object *) newpkg;
element_copy(elem, newelem);
newpkg->text = text_copy(pkg->text);
for (i=0;i<8;i++) {
newobj->connections[i] = &newpkg->connections[i];
newpkg->connections[i].object = newobj;
newpkg->connections[i].connected = NULL;
newpkg->connections[i].pos = pkg->connections[i].pos;
newpkg->connections[i].last_pos = pkg->connections[i].last_pos;
}
smallpackage_update_data(newpkg);
return (Object *)newpkg;
}
static DiaObject *
function_copy(Function *pkg)
{
int i;
Function *newpkg;
Element *elem, *newelem;
DiaObject *newobj;
elem = &pkg->element;
newpkg = g_malloc0(sizeof(Function));
newelem = &newpkg->element;
newobj = &newelem->object;
element_copy(elem, newelem);
newpkg->text = text_copy(pkg->text);
for (i=0;i<NUM_CONNECTIONS;i++) {
newobj->connections[i] = &newpkg->connections[i];
newpkg->connections[i].object = newobj;
newpkg->connections[i].connected = NULL;
newpkg->connections[i].pos = pkg->connections[i].pos;
newpkg->connections[i].last_pos = pkg->connections[i].last_pos;
newpkg->connections[i].flags = pkg->connections[i].flags;
}
newpkg->is_wish = pkg->is_wish ;
newpkg->is_user = pkg->is_user ;
newpkg->element.extra_spacing.border_trans = pkg->element.extra_spacing.border_trans ;
function_update_data(newpkg);
return &newpkg->element.object;
}
static int cftp_client_send_directory(struct cftp_descriptor *desc, const char *dir_in, const char *dir_out)
{
DIR *dp;
struct dirent *entry;
int ret;
char tmp_file_in[256], tmp_file_out[256];
char *p_in, *p_out;
dp = opendir(dir_in);
if (dp == NULL)
{
print_error("fail to open directory %s", dir_in);
return -EFAULT;
}
p_in = text_path_cat(tmp_file_in, sizeof(tmp_file_in), dir_in, NULL);
p_out = text_path_cat(tmp_file_out, sizeof(tmp_file_out), dir_out, NULL);
while ((entry = readdir(dp)))
{
if (text_is_dot_name(entry->d_name))
{
continue;
}
text_copy(p_in, entry->d_name);
text_copy(p_out, entry->d_name);
ret = cftp_client_send_file(desc, tmp_file_in, 0, tmp_file_out, 0, 0);
if (ret < 0)
{
goto out_close_dir;
}
}
ret = 0;
out_close_dir:
closedir(dp);
return ret;
}
int property_get(const char *key, char *value, const char *default_value)
{
int length;
length = __system_property_get(key, value);
if (length < 0 && default_value) {
return text_copy(value, default_value) - value;
}
return length;
}
char *uevent_get_property_base(char *props[], int prop_count, const char *prefix, char *buff)
{
for (prop_count--; prop_count >= 0; prop_count--) {
if (text_lhcmp(prefix, props[prop_count]) == 0) {
text_copy(buff, props[prop_count] + text_len(prefix));
return buff;
}
}
return NULL;
}
// Color all the items grey:
static void grey_serverlist (void)
{
char *str;
int i;
for(i=0; i<m_serverlist.nummapped; i++)
{
if ((unsigned char)m_serverlist.info[i][0] != SCHAR_COLOR)
{
str = text_copy(va("%c4%s", SCHAR_COLOR, m_serverlist.info[i]));
Z_Free(m_serverlist.info[i]);
m_serverlist.info[i] = str;
}
}
}
int get_next_line(int const fd, char **line)
{
static char *offset = NULL;
int ret;
if (!(line))
return (-1);
if (!offset)
offset = ft_strnew(0);
if ((ret = text_copy(fd, &offset)) == -1)
return (-1);
offset = get_line(offset, line);
if ((!ret && !ft_strlen(offset) && !ft_strlen(*line)))
return (0);
else
return (1);
}
int file_cache_init(struct file_cache *cache, const char *pathname, int flags, mode_t mode)
{
int ret;
int fd;
if (cache == NULL)
{
return -EINVAL;
}
fd = open(pathname, flags, mode);
if (fd < 0)
{
return fd;
}
if (cache->cache_blocks == 0)
{
cache->cache_blocks = DEFAULT_CACHE_BLOCKS;
}
if (cache->block_size == 0)
{
cache->block_size = DEFAULT_BLOCK_SIZE;
}
ret = ffile_cache_init(cache, cache->cache_blocks * cache->block_size, cache->cache_blocks * cache->block_size);
if (ret < 0)
{
goto out_close_fd;
}
cache->fd = fd;
cache->start_block = 0;
cache->read_pointer = cache->write_pointer = cache->start_block;
text_copy(cache->pathname, pathname);
return 0;
out_close_fd:
close(fd);
return ret;
}
static ssize_t cftp_send_file_reuest(struct cftp_descriptor *desc, struct cftp_file_request *req, const char *filename, struct stat *st, u32 offset, u32 size, int read)
{
ssize_t sendlen;
if (read) {
req->type = CFTP_PACKAGE_FILE_READ;
} else {
req->type = CFTP_PACKAGE_FILE_WRITE;
req->st_mode = st->st_mode;
req->st_rdev = st->st_rdev;
}
req->size = size;
req->offset = offset;
sendlen = text_copy(req->filename, filename) - (char *) req + 1;
return cftp_send_data_retry(desc, req, sendlen, desc->retry_count);
}
static char *get_bt_mac_file(const char *system_mnt_point, char *pathname, size_t size)
{
unsigned int i;
const char *bt_mac_files[] = {I600_BT_MAC_FILE, I200_BT_MAC_FILE};
char *name_p;
name_p = text_path_cat(pathname, size, system_mnt_point, NULL);
for (i = 0; i < ARRAY_SIZE(bt_mac_files); i++)
{
text_copy(name_p, bt_mac_files[i]);
if (access(pathname, W_OK) == 0)
{
return pathname;
}
}
return NULL;
}
static Object *
rendobj_copy(RenderObject *rend_obj)
{
int i;
RenderObject *newrend_obj;
Element *elem, *newelem;
Object *newobj;
elem = &rend_obj->element;
newrend_obj = g_malloc(sizeof(RenderObject));
newelem = &newrend_obj->element;
newobj = &newelem->object;
element_copy(elem, newelem);
newrend_obj->desc = rend_obj->desc;
newrend_obj->magnify = rend_obj->magnify;
if (rend_obj->desc->use_text) {
newrend_obj->text = text_copy(rend_obj->text);
} else {
newrend_obj->text = NULL;
}
newrend_obj->connections = g_new(ConnectionPoint,
rend_obj->desc->num_connection_points);
for (i=0;i<rend_obj->desc->num_connection_points;i++) {
newobj->connections[i] = &newrend_obj->connections[i];
newrend_obj->connections[i].object = newobj;
newrend_obj->connections[i].pos = rend_obj->connections[i].pos;
newrend_obj->connections[i].last_pos = rend_obj->connections[i].last_pos;
newrend_obj->connections[i].connected = NULL;
}
rendobj_update_data(newrend_obj);
return (Object *)newrend_obj;
}
static int kogado_put(FILE *fi, FILE *fo) {
uint a, i, n, t[13], p, x = 0;
READ(t, 0x34);
if(memcmp(t, "SR01", 4)) return -1;
fwrite(t, 1, 0x34, fo);
for(i = 0x34; i < t[10]; i++) {
LODSB; fputc(a, fo);
}
for(i = 0; i < t[12]; i++) {
if(!x) x = text_num();
if(i == x) {
if(fread(&a, 1, 2, fi) != 2) break;
n = (ushort)a;
if(n < 2) break; n -= 2;
if(n) do { LODSB; } while(--n);
a = ftell(fo);
fwrite(&n, 1, 2, fo);
x = text_copy(fo);
fputc(0, fo);
n = ftell(fo) - a;
if(n & 1) { n++; fputc(0, fo); }
if(fseek(fo, a, SEEK_SET)) return -1;
fwrite(&n, 1, 2, fo);
if(fseek(fo, a + n, SEEK_SET)) return -1;
} else {
if(fread(&a, 1, 2, fi) != 2) break;
fwrite(&a, 1, 2, fo);
n = (ushort)a;
if(n < 2) break; n -= 2;
if(n) do { LODSB; fputc(a, fo); } while(--n);
}
}
a = ftell(fo);
t[1] = a;
t[11] = a - t[10];
if(fseek(fo, 0, SEEK_SET)) return -1;
fwrite(t, 1, 0x34, fo);
return 0;
}
int bootimg_unpack(const char *input, const char *output, bool dt_support)
{
int fd;
int ret;
int count;
char *filename;
char pathname[1024];
struct bootimg_header hdr;
struct bootimg_image images[4];
fd = open(input, O_RDONLY);
if (fd < 0)
{
pr_error_info("open file `%s'", input);
return fd;
}
ret = bootimg_read_header(fd, &hdr);
if (ret < 0)
{
pr_red_info("bootimg_read_header");
goto out_close_fd;
}
bootimg_header_dump(&hdr);
filename = text_copy(pathname, output);
ret = mkdir_hierarchy(pathname, 0777);
if (ret < 0)
{
pr_red_info("mkdir_hierarchy");
goto out_close_fd;
}
*filename++ = '/';
count = 0;
if (hdr.kernel_size > 0)
{
images[count].size = hdr.kernel_size;
images[count++].name = FILE_KERNEL_NAME;
}
if (hdr.ramdisk_size > 0)
{
images[count].size = hdr.ramdisk_size;
images[count++].name = FILE_RAMDISK_NAME;
}
if (hdr.second_size > 0)
{
images[count].size = hdr.second_size;
images[count++].name = FILE_SECOND_NAME;
}
else
{
strcpy(filename, FILE_SECOND_NAME);
unlink(filename);
}
if (hdr.dt_size > 0 && dt_support)
{
images[count].size = hdr.dt_size;
images[count++].name = FILE_DT_NAME;
}
else
{
strcpy(filename, FILE_DT_NAME);
unlink(filename);
}
images[count].size = 0;
images[count++].name = FILE_REMAIN_NAME;
if (count > 0)
{
struct bootimg_image *p, *p_end;
for (p = images, p_end = p + count; p < p_end; p++)
{
strcpy(filename, p->name);
println("%s -> %s", p->name, pathname);
if (p->size > 0)
{
ret = cavan_file_seek_next_page(fd, hdr.page_size);
if (ret < 0)
{
pr_red_info("cavan_file_seek_next_page");
goto out_close_fd;
}
ret = file_ncopy2(fd, pathname, p->size, O_WRONLY | O_TRUNC | O_CREAT, 0777);
}
else
{
ret = file_copy2(fd, pathname, O_WRONLY | O_TRUNC | O_CREAT, 0777);
}
if (ret < 0)
{
pr_red_info("file_copy2");
goto out_close_fd;
}
}
}
if (hdr.cmdline[0])
{
strcpy(filename, FILE_CMDLINE_TXT);
println("cmdline -> %s", pathname);
if (hdr.extra_cmdline[0])
{
char *p;
char buff[sizeof(hdr.cmdline) + sizeof(hdr.extra_cmdline)];
p = text_copy(buff, (char *) hdr.cmdline);
p = text_copy(p, (char *) hdr.extra_cmdline);
ret = file_writeto(pathname, buff, p - buff, 0, O_TRUNC);
if (ret < 0)
{
pr_red_info("file_writeto");
goto out_close_fd;
}
}
else
{
ret = file_writeto(pathname, hdr.cmdline, strlen((char *) hdr.cmdline), 0, O_TRUNC);
if (ret < 0)
{
pr_red_info("file_writeto");
goto out_close_fd;
}
}
}
strcpy(filename, FILE_REPACK_SH);
ret = bootimg_gen_repack_script(&hdr, pathname, dt_support);
if (ret < 0)
{
pr_red_info("bootimg_gen_pack_script");
goto out_close_fd;
}
strcpy(filename, FILE_CONFIG_TXT);
ret = bootimg_write_config_file(&hdr, pathname);
if (ret < 0)
{
pr_red_info("bootimg_write_config_file");
goto out_close_fd;
}
ret = 0;
out_close_fd:
close(fd);
return ret;
}
int package(const char *pkg_name, const char *dir_name)
{
int ret;
int pkg_fd;
struct swan_package_info pkg_info;
struct swan_file_info file_info;
char tmp_path[1024], *name_p;
int shrink_image_table[] = {
SWAN_IMAGE_SYSTEM,
SWAN_IMAGE_RECOVERY,
SWAN_IMAGE_USERDATA,
SWAN_IMAGE_VENDOR,
};
struct swan_image_info *p, *p_end;
name_p = text_path_cat(tmp_path, sizeof(tmp_path), dir_name, NULL);
if (swan_machine_type == SWAN_BOARD_UNKNOWN) {
text_copy(name_p, "system.img");
swan_machine_type = get_swan_board_type_by_system_img(tmp_path);
}
if (swan_machine_type == SWAN_BOARD_UNKNOWN) {
pr_err_info("Machine type no set");
} else {
struct swan_image_info *img_info;
img_info = get_swan_image_info_by_type(SWAN_IMAGE_LOGO);
if (img_info) {
text_copy(img_info->filename, get_logo_name_by_board_type(swan_machine_type));
}
img_info = get_swan_image_info_by_type(SWAN_IMAGE_BUSYBOX);
if (img_info) {
text_copy(img_info->filename, get_busybox_name_by_board_type(swan_machine_type));
}
}
pkg_fd = open(pkg_name, O_RDWR | O_CREAT | O_SYNC | O_TRUNC | O_BINARY, 0777);
if (pkg_fd < 0) {
pr_err_info("open file \"%s\"", pkg_name);
return -1;
}
text_copy(name_p, HEADER_BIN_NAME);
ret = write_upgrade_program(pkg_fd, &file_info, tmp_path);
if (ret < 0) {
pr_err_info("write_upgrade_program");
goto out_close_pkg;
}
ret = lseek(pkg_fd, sizeof(pkg_info), SEEK_CUR);
if (ret < 0) {
pr_err_info("lseek");
goto out_close_pkg;
}
ret = write_resource_image(pkg_fd, &pkg_info, dir_name, get_resource_name_by_board_type(swan_machine_type),
RESOURCE_IMAGE_NAME, I600_RESOURCE_NAME, I200_RESOURCE_NAME, MODEM_RESOURCE_NAME, NULL);
if (ret < 0) {
pr_err_info("write_resource_image");
goto out_close_pkg;
}
pkg_info.image_count = 0;
for (p = swan_images, p_end = p + ARRAY_SIZE(swan_images); p < p_end; p++) {
text_copy(name_p, p->filename);
if (array_has_element(p->type, (int *) swan_exclude_images, swan_exclude_image_count) || file_test(tmp_path, "r") < 0) {
println_cyan("exclude image \"%s\"", tmp_path);
continue;
}
if (swan_need_shrink && array_has_element(p->type, shrink_image_table, ARRAY_SIZE(shrink_image_table))) {
ret = swan_shrink_image(dir_name, p);
if (ret < 0) {
pr_err_info("image_shrink");
goto out_close_pkg;
}
}
ret = write_simple_image(pkg_fd, dir_name, p, &swan_emmc_part_table);
if (ret < 0) {
pr_err_info("write_image");
goto out_close_pkg;
}
pkg_info.image_count++;
}
pkg_info.crc32 = 0;
ret = ffile_crc32_seek(pkg_fd, sizeof(file_info) + file_info.header_size + sizeof(pkg_info), 0, &pkg_info.crc32);
if (ret < 0) {
pr_err_info("ffile_crc32");
goto out_close_pkg;
}
strncpy(pkg_info.volume, swan_vfat_volume, sizeof(pkg_info.volume));
pkg_info.mkfs_mask = swan_mkfs_mask;
pkg_info.board_type = swan_machine_type;
pkg_info.upgrade_flags = swan_upgrade_flags;
pkg_info.part_table = swan_emmc_part_table;
show_package_info(&pkg_info);
ret = lseek(pkg_fd, sizeof(file_info) + file_info.header_size, SEEK_SET);
if (ret < 0) {
pr_err_info("lseek");
goto out_close_pkg;
}
ret = write_package_info(pkg_fd, &pkg_info);
if (ret < 0) {
pr_err_info("write_package_info");
goto out_close_pkg;
}
ret = swan_set_md5sum(pkg_name);
if (ret < 0) {
pr_err_info("swan_set_md5sum");
}
out_close_pkg:
close(pkg_fd);
if (ret < 0) {
remove(pkg_name);
return ret;
}
return 0;
}
static int ftp_list_directory1(const char *dirpath, const char *newline)
{
int fd;
DIR *dp;
int ret;
struct dirent *ep;
char *filename;
char pathname[1024];
char buff[1024];
char *buff_end = buff + sizeof(buff);
#if FTP_DEBUG
pr_bold_info("dirpath = `%s'", dirpath);
#endif
dp = opendir(dirpath);
if (dp == NULL)
{
pr_red_info("opendir failed");
return -EFAULT;
}
fd = cavan_temp_file_open(pathname, sizeof(pathname), "cavan-ftp-XXXXXX");
if (fd < 0)
{
pr_red_info("cavan_temp_file_open");
ret = fd;
goto out_closedir;
}
filename = text_path_cat(pathname, sizeof(pathname), dirpath, NULL);
while ((ep = readdir(dp)))
{
char *p;
text_copy(filename, ep->d_name);
p = ftp_file_stat_tostring(pathname, buff, buff_end);
if (p == NULL)
{
continue;
}
p += snprintf(p, buff_end - p, " %s%s", ep->d_name, newline);
ret = ffile_write(fd, buff, p - buff);
if (ret < 0)
{
pr_red_info("ffile_write");
goto out_close_fd;
}
}
if (lseek(fd, 0, SEEK_SET) != 0)
{
pr_error_info("lseek");
ret = -EFAULT;
goto out_close_fd;
}
closedir(dp);
return fd;
out_close_fd:
close(fd);
out_closedir:
closedir(dp);
return ret;
}
static int ftp_client_receive_file(struct network_client *client, const char *ip, u16 port)
{
int ret;
int sockfd, data_sockfd;
ssize_t rdlen;
char buff[1024], *p;
struct sockaddr_in addr;
socklen_t addrlen;
sockfd = inet_create_tcp_service(port);
if (sockfd < 0)
{
pr_red_info("inet_create_tcp_service");
return sockfd;
}
p = text_copy(buff, "PORT ");
p = text_replace_char2(ip, p, '.', ',');
p += sprintf(p, ",%d,%d\r\n", port >> 8, port & 0xFF);
rdlen = ftp_client_send_command(client, buff, p - buff, buff, sizeof(buff));
if (rdlen < 0)
{
pr_red_info("ftp_client_send_command");
return rdlen;
}
rdlen = ftp_client_send_command(client, "LIST\r\n", 0, buff, sizeof(buff));
if (rdlen < 0)
{
pr_red_info("ftp_client_send_command");
return rdlen;
}
data_sockfd = inet_accept(sockfd, &addr, &addrlen);
if (data_sockfd < 0)
{
pr_red_info("inet_accept");
ret = data_sockfd;
goto out_close_sockfd;
}
while (1)
{
rdlen = inet_recv(data_sockfd, buff, sizeof(buff));
if (rdlen < 0)
{
pr_red_info("inet_recv");
ret = rdlen;
goto out_close_data_link;
}
if (rdlen == 0)
{
pr_green_info("data receive complete");
break;
}
#if FTP_DEBUG
print_ntext(buff, rdlen);
#endif
}
ret = 0;
out_close_data_link:
shutdown(data_sockfd, SHUT_RDWR);
inet_close_tcp_socket(data_sockfd);
out_close_sockfd:
inet_close_tcp_socket(sockfd);
return ret;
}
static int ftp_service_cmdline(struct cavan_ftp_service *service, struct network_client *client)
{
int fd;
int ret;
u32 command;
char file_type;
const char *reply;
char rep_pasv[64];
struct pollfd pfds[2];
enum cavan_ftp_state state;
struct network_url data_url;
ssize_t wrlen, rdlen, replen;
struct network_client data_link;
struct network_service data_service;
char abs_path[1024], curr_path[1024];
char cmd_buff[1024], rep_buff[1024], *cmd_arg, *cmd_end;
file_type = 0;
data_link.sockfd = -1;
data_service.sockfd = -1;
network_url_init(&data_url, "tcp", NULL, 0, NULL);
replen = 0;
reply = "220 Cavan ftp server ready.\r\n";
state = FTP_STATE_READY;
text_copy(curr_path, service->home);
pfds[0].fd = -1;
pfds[1].fd = client->sockfd;
pfds[0].events = pfds[1].events = POLLIN;
while (1)
{
if (replen == 0)
{
replen = strlen(reply);
}
#if FTP_DEBUG
println("reply = %s", reply);
#endif
wrlen = client->send(client, reply, replen);
if (wrlen < 0)
{
pr_red_info("inet_send_text");
goto out_close_data_link;
}
replen = 0;
reply = rep_buff;
label_poll:
ret = poll(pfds, NELEM(pfds), FTP_TIMEOUT_MS);
if (ret < 1)
{
if (ret < 0)
{
pr_error_info("poll");
goto out_close_data_link;
}
goto label_poll;
}
if (pfds[0].revents == POLLIN)
{
if (data_link.sockfd >= 0)
{
network_client_close(&data_link);
}
ret = network_service_accept(&data_service, &data_link);
if (ret < 0)
{
pr_red_info("network_service_accept");
goto out_network_service_close;
}
if (pfds[1].revents != POLLIN)
{
goto label_poll;
}
}
rdlen = client->recv(client, cmd_buff, sizeof(cmd_buff) - 1);
if (rdlen < 3)
{
goto out_close_data_link;
}
for (cmd_end = cmd_buff + rdlen - 1; cmd_end > cmd_buff && byte_is_lf(*cmd_end); cmd_end--);
*++cmd_end = 0;
for (cmd_arg = cmd_buff; cmd_arg < cmd_end && !byte_is_space(*cmd_arg); cmd_arg++);
while ( cmd_arg < cmd_end && byte_is_space(*cmd_arg))
{
*cmd_arg++ = 0;
}
#if FTP_DEBUG
println("command = `%s', args = `%s'", cmd_buff, cmd_arg);
#endif
command = *(u32 *) cmd_buff;
switch (command)
{
case FTP_BUILD_CMD('q', 'u', 'i', 't'):
case FTP_BUILD_CMD('Q', 'U', 'I', 'T'):
network_client_send_text(client, "221 Goodbye.\r\n");
return 0;
case FTP_BUILD_CMD('u', 's', 'e', 'r'):
case FTP_BUILD_CMD('U', 'S', 'E', 'R'):
if (state < FTP_STATE_USER_RECVED)
{
state = FTP_STATE_USER_RECVED;
reply = "331 Please input password.\r\n";
}
else
{
reply = "331 Any password will do.\r\n";
}
break;
case FTP_BUILD_CMD('p', 'a', 's', 's'):
case FTP_BUILD_CMD('P', 'A', 'S', 'S'):
if (state < FTP_STATE_USER_RECVED)
{
reply = "530 Please input username.\r\n";
}
else if (state < FTP_STATE_LOGINED)
{
state = FTP_STATE_LOGINED;
reply = "230 User login successfull.\r\n";
}
else
{
reply = "230 Alreay logged in.\r\n";
}
break;
default:
if (state < FTP_STATE_LOGINED)
{
if (state < FTP_STATE_USER_RECVED)
{
reply = "530 Please login with USER and PASS.\r\n";
}
else
{
reply = "530 Please login with PASS.\r\n";
}
break;
}
switch (command)
{
case FTP_BUILD_CMD('p', 'o', 'r', 't'):
case FTP_BUILD_CMD('P', 'O', 'R', 'T'):
{
int temp[6];
ret = sscanf(cmd_arg, "%d,%d,%d,%d,%d,%d", temp, temp + 1, temp + 2, temp + 3, temp + 4, temp + 5);
if (ret == 6)
{
snprintf(data_url.memory, sizeof(data_url.memory), "%d.%d.%d.%d", temp[0], temp[1], temp[2], temp[3]);
data_url.hostname = data_url.memory;
data_url.port = temp[4] << 8 | temp[5];
reply = "200 PORT command complete.\r\n";
}
else
{
reply = "501 Argument error.\r\n";
}
break;
}
case FTP_BUILD_CMD('o', 'p', 't', 's'):
case FTP_BUILD_CMD('O', 'P', 'T', 'S'):
reply = "200 OPTS command complete.\r\n";
break;
case FTP_BUILD_CMD('p', 'w', 'd', 0):
case FTP_BUILD_CMD('P', 'W', 'D', 0):
case FTP_BUILD_CMD('x', 'p', 'w', 'd'):
case FTP_BUILD_CMD('X', 'P', 'W', 'D'):
replen = snprintf(rep_buff, sizeof(rep_buff), "257 \"%s\"\r\n", curr_path);
break;
case FTP_BUILD_CMD('t', 'y', 'p', 'e'):
case FTP_BUILD_CMD('T', 'Y', 'P', 'E'):
reply = "200 TYPE commnd complete.\r\n";
file_type = cmd_buff[5];
break;
case FTP_BUILD_CMD('s', 'y', 's', 't'):
case FTP_BUILD_CMD('S', 'Y', 'S', 'T'):
reply = "215 UNIX Type L8.\r\n";
break;
case FTP_BUILD_CMD('c', 'w', 'd', 0):
case FTP_BUILD_CMD('C', 'W', 'D', 0):
case FTP_BUILD_CMD('x', 'c', 'w', 'd'):
case FTP_BUILD_CMD('X', 'C', 'W', 'D'):
if (*cmd_arg)
{
ftp_get_abs_path(curr_path, cmd_arg, abs_path, sizeof(abs_path));
if (access(abs_path, F_OK) < 0)
{
reply = "550 Failed to change directory.\r\n";
break;
}
prettify_pathname_base(abs_path, curr_path, sizeof(curr_path));
}
else
{
text_copy(curr_path, service->home);
}
reply = "250 CWD commnd complete.\r\n";
break;
case FTP_BUILD_CMD('l', 'i', 's', 't'):
case FTP_BUILD_CMD('L', 'I', 'S', 'T'):
if (data_link.sockfd < 0 && data_url.port == 0)
{
reply = "550 Please run PORT or PASV first.\r\n";
break;
}
fd = ftp_list_directory1(curr_path, file_type == 'I' ? "\n" : "\r\n");
if (fd < 0)
{
replen = snprintf(rep_buff, sizeof(rep_buff), "550 List directory failed: %s.\r\n", strerror(errno));
break;
}
wrlen = network_client_send_text(client, "150 List directory complete.\r\n");
if (wrlen < 0)
{
pr_red_info("ftp_send_text");
close(fd);
goto out_close_data_link;
}
ret = ftp_server_send_file1(&data_link, &data_url, fd);
close(fd);
if (ret < 0)
{
replen = snprintf(rep_buff, sizeof(rep_buff), "550 Send list failed: %s.\r\n", strerror(errno));
}
else
{
reply = "226 List send complete.\r\n";
}
break;
case FTP_BUILD_CMD('s', 'i', 'z', 'e'):
case FTP_BUILD_CMD('S', 'I', 'Z', 'E'):
{
struct stat st;
if (*cmd_arg == 0 || stat(ftp_get_abs_path(curr_path, cmd_arg, abs_path, sizeof(abs_path)), &st))
{
replen = snprintf(rep_buff, sizeof(rep_buff), "550 get file size failed: %s.\r\n", strerror(errno));
}
else
{
replen = snprintf(rep_buff, sizeof(rep_buff), "213 %" PRINT_FORMAT_OFF "\r\n", st.st_size);
}
break;
}
case FTP_BUILD_CMD('r', 'e', 't', 'r'):
case FTP_BUILD_CMD('R', 'E', 'T', 'R'):
fd = open(ftp_get_abs_path(curr_path, cmd_arg, abs_path, sizeof(abs_path)), O_RDONLY);
if (fd < 0)
{
reply = "550 Open file failed.\r\n";
break;
}
wrlen = network_client_send_text(client, "125 Starting transfer\r\n");
if (wrlen < 0)
{
pr_red_info("network_client_send_text");
close(fd);
goto out_close_data_link;
}
ret = ftp_server_send_file1(&data_link, &data_url, fd);
close(fd);
if (ret < 0)
{
reply = "550 Send file failed.\r\n";
}
else
{
reply = "226 Transfer complete.\r\n";
}
break;
case FTP_BUILD_CMD('s', 't', 'o', 'r'):
case FTP_BUILD_CMD('S', 'T', 'O', 'R'):
fd = open(ftp_get_abs_path(curr_path, cmd_arg, abs_path, sizeof(abs_path)), O_WRONLY | O_CREAT, 0777);
if (fd < 0)
{
reply = "550 Open file failed.\r\n";
break;
}
wrlen = network_client_send_text(client, "125 Starting transfer\r\n");
if (wrlen < 0)
{
pr_error_info("ftp_send_text");
close(fd);
goto out_close_data_link;
}
ret = ftp_server_receive_file1(&data_link, &data_url, fd);
close(fd);
if (ret < 0)
{
reply = "550 Receive file failed.\r\n";
}
else
{
reply = "226 Transfer complete.\r\n";
}
break;
case FTP_BUILD_CMD('p', 'a', 's', 'v'):
case FTP_BUILD_CMD('P', 'A', 'S', 'V'):
if (data_service.sockfd < 0)
{
ret = ftp_data_service_open(&data_service, client, rep_pasv, sizeof(rep_pasv));
if (ret < 0)
{
pr_red_info("ftp_data_service_open");
return ret;
}
replen = ret;
pfds[0].fd = data_service.sockfd;
}
reply = rep_pasv;
break;
case FTP_BUILD_CMD('d', 'e', 'l', 'e'):
case FTP_BUILD_CMD('D', 'E', 'L', 'E'):
ret = remove(ftp_get_abs_path(curr_path, cmd_arg, abs_path, sizeof(abs_path)));
if (ret < 0)
{
replen = snprintf(rep_buff, sizeof(rep_buff), "550 remove %s failed: %s.\r\n", cmd_arg, strerror(errno));
}
else
{
reply = "200 DELE command complete.\r\n";
}
break;
case FTP_BUILD_CMD('r', 'm', 'd', 0):
case FTP_BUILD_CMD('R', 'M', 'D', 0):
ret = rmdir(ftp_get_abs_path(curr_path, cmd_arg, abs_path, sizeof(abs_path)));
if (ret < 0)
{
replen = snprintf(rep_buff, sizeof(rep_buff), "550 remove %s failed: %s.\r\n", cmd_arg, strerror(errno));
}
else
{
reply = "200 DELE command complete.\r\n";
}
break;
case FTP_BUILD_CMD('m', 'k', 'd', 0):
case FTP_BUILD_CMD('M', 'K', 'D', 0):
ret = mkdir(ftp_get_abs_path(curr_path, cmd_arg, abs_path, sizeof(abs_path)), 0777);
if (ret < 0)
{
replen = snprintf(rep_buff, sizeof(rep_buff), "550 create directory %s failed: %s.\r\n", cmd_arg, strerror(errno));
}
else
{
reply = "200 MKD command complete.\r\n";
}
break;
case FTP_BUILD_CMD('m', 'd', 't', 'm'):
case FTP_BUILD_CMD('M', 'D', 'T', 'M'):
{
struct stat st;
ret = stat(ftp_get_abs_path(curr_path, cmd_arg, abs_path, sizeof(abs_path)), &st);
if (ret < 0)
{
replen = snprintf(rep_buff, sizeof(rep_buff), "550 get file stat failed: %s.\r\n", strerror(errno));
}
else
{
struct tm ti;
if (localtime_r((time_t *) &st.st_atime, &ti) == NULL)
{
replen = snprintf(rep_buff, sizeof(rep_buff), "550 get localtime failed: %s.\r\n", strerror(errno));
}
else
{
replen = snprintf(rep_buff, sizeof(rep_buff), "213 %04d%02d%02d%02d%02d%02d\r\n", \
ti.tm_year + 1900, ti.tm_mon + 1, ti.tm_mday, ti.tm_hour, ti.tm_min, ti.tm_sec);
}
}
break;
}
case FTP_BUILD_CMD('n', 'o', 'o', 'p'):
case FTP_BUILD_CMD('N', 'O', 'O', 'P'):
reply = "200 NOOP commnd complete.\r\n";
break;
case FTP_BUILD_CMD('r', 'n', 'f', 'r'):
case FTP_BUILD_CMD('R', 'N', 'F', 'R'):
{
char rnfr_path[1024];
ftp_get_abs_path(curr_path, cmd_arg, rnfr_path, sizeof(rnfr_path));
reply = "350 RNFR command complete.\r\n";
break;
}
case FTP_BUILD_CMD('r', 'n', 't', 'o'):
case FTP_BUILD_CMD('R', 'N', 'T', 'O'):
{
char rnfr_path[1024];
ftp_get_abs_path(curr_path, cmd_arg, abs_path, sizeof(abs_path));
ret = rename(rnfr_path, abs_path);
if (ret < 0)
{
replen = snprintf(rep_buff, sizeof(rep_buff), "550 Rename %s to %s failed[%s].\r\n", rnfr_path, abs_path, strerror(errno));
}
else
{
replen = snprintf(rep_buff, sizeof(rep_buff), "250 Rename %s to %s successfully.\r\n", rnfr_path, abs_path);
}
break;
}
case FTP_BUILD_CMD('s', 'i', 't', 'e'):
case FTP_BUILD_CMD('S', 'I', 'T', 'E'):
command = *(u32 *) cmd_arg;
switch (command)
{
case FTP_BUILD_CMD('h', 'e', 'l', 'p'):
case FTP_BUILD_CMD('H', 'E', 'L', 'P'):
reply = "214 UNMASK HELP\r\n";
break;
default:
goto label_unsupport_command;
}
break;
case FTP_BUILD_CMD('f', 'e', 'a', 't'):
case FTP_BUILD_CMD('F', 'E', 'A', 'T'):
reply = "211 MDTM SIZE PASV PORT RNTO MKD RMD DELE RETR STOR\r\n";
break;
default:
label_unsupport_command:
pr_red_info("unsupport command: `%s'", cmd_buff);
reply = "500 Unknown command.\r\n";
}
}
}
out_close_data_link:
if (data_link.sockfd >= 0)
{
network_client_close(&data_link);
}
out_network_service_close:
if (data_service.sockfd >= 0)
{
network_service_close(&data_service);
}
return 0;
}
int ftp_client_run(struct network_url *url, const char *username, const char *password)
{
int ret;
char buff[1024], *p;
ssize_t wrlen, rdlen;
struct network_client client;
ret = network_client_open(&client, url, 0);
if (ret < 0)
{
pr_red_info("network_client_open");
return ret;
}
ret = ftp_client_login(&client, username, password);
if (ret < 0)
{
pr_red_info("ftp_client_login");
return ret;
}
while (1)
{
while (1)
{
print("cavan-ftp> ");
for (p = buff; (*p = getchar()) != '\n'; p++);
if (p > buff)
{
p = text_copy(p, "\r\n");
break;
}
}
if (text_lhcmp("ls", buff) == 0)
{
println("list command");
ftp_client_receive_file(&client, url->hostname, 6789);
}
else
{
wrlen = client.send(&client, buff, p - buff);
if (wrlen < 0)
{
pr_red_info("inet_send");
ret = wrlen;
break;
}
}
rdlen = client.recv(&client, buff, sizeof(buff));
if (rdlen < 0)
{
pr_red_info("client.recv");
ret = rdlen;
break;
}
buff[rdlen] = 0;
println("%s", buff);
}
network_client_close(&client);
return ret;
}
int cftp_client_send_file(struct cftp_descriptor *desc, const char *file_in, u32 offset_in, const char *file_out, u32 offset_out, size_t size)
{
int fd;
int ret;
struct stat st;
ssize_t recvlen, sendlen, readlen;
u16 blk_num;
union cftp_message *msg;
struct cftp_data_package *data_msg;
size_t max_xfer_length, max_data_length;
struct progress_bar bar;
ret = file_lstat(file_in, &st);
if (ret < 0) {
pr_err_info("fstat");
return ret;
}
max_xfer_length = desc->max_xfer_length;
msg = malloc(max_xfer_length);
if (msg == NULL) {
pr_err_info("malloc");
return -ENOMEM;
}
switch (st.st_mode & S_IFMT) {
case S_IFREG:
println("Send File: %s => %s", file_in, file_out);
break;
case S_IFBLK:
case S_IFCHR:
println("Send Devicce: %s => %s", file_in, file_out);
return cftp_client_send_special_file(desc, &st, &msg->file_req, text_copy(msg->file_req.filename, file_out) - msg->file_req.filename + 1);
case S_IFLNK:
println("Send Symlink: %s => %s", file_in, file_out); {
char *p;
p = text_copy(msg->file_req.filename, file_out) + 1;
ret = readlink(file_in, p, 1024);
if (ret < 0) {
pr_err_info("readlink");
return ret;
}
return cftp_client_send_special_file(desc, &st, &msg->file_req, p - msg->file_req.filename + ret + 1);
}
case S_IFDIR:
println("Send Directory: %s => %s", file_in, file_out);
ret = cftp_client_send_special_file(desc, &st, &msg->file_req, text_copy(msg->file_req.filename, file_out) - msg->file_req.filename + 1);
if (ret < 0) {
pr_err_info("cftp_client_send_special_file");
return ret;
}
return cftp_client_send_directory(desc, file_in, file_out);
default:
pr_warn_info("File %s type is unknown", file_in);
return 0;
}
fd = open(file_in, O_RDONLY);
if (fd < 0) {
pr_err_info("open file %s failed", file_in);
goto out_free_msg;
}
if (offset_in) {
ret = lseek(fd, offset_in, SEEK_SET);
if (ret < 0) {
pr_err_info("lseek");
goto out_close_file;
}
}
if (size == 0) {
size = st.st_size - offset_in;
}
data_msg = malloc(max_xfer_length);
if (data_msg == NULL) {
pr_err_info("malloc");
ret = -ENOMEM;
goto out_close_file;
}
sendlen = cftp_send_file_reuest(desc, (void *) msg, file_out, &st, offset_out, size, 0);
if (sendlen < 0) {
ret = sendlen;
pr_err_info("cftp_send_data_retry");
goto out_free_data_msg;
}
println("seek = %s", size2text(offset_out));
println("skip = %s", size2text(offset_in));
println("size = %s", size2text(size));
blk_num = 0;
data_msg->type = CFTP_PACKAGE_DATA;
max_data_length = max_xfer_length - sizeof(*data_msg);
progress_bar_init(&bar, size, 0, PROGRESS_BAR_TYPE_DATA);
readlen = max_data_length;
while (1) {
recvlen = cftp_receive_data(desc, msg, max_xfer_length);
if (recvlen < 0) {
pr_err_info("cftp_receive_data");
ret = recvlen;
goto out_free_data_msg;
}
switch (msg->type) {
case CFTP_PACKAGE_ERROR:
show_error_message((struct cftp_error_message *) msg);
ret = -EFAULT;
goto out_free_data_msg;
case CFTP_PACKAGE_ACK:
if (msg->ack_msg.blk_num == blk_num) {
if ((size_t) readlen < max_data_length) {
ret = 0;
progress_bar_finish(&bar);
println("Send data complete");
goto out_free_data_msg;
}
readlen = read(fd, data_msg->data, max_data_length);
if (readlen < 0) {
pr_err_info("read");
cftp_send_error_message(desc, (struct cftp_error_message *) msg, "read file failed");
ret = readlen;
goto out_free_data_msg;
}
data_msg->blk_num = blk_num++;
progress_bar_add(&bar, readlen);
} else {
pr_warn_info("%d != %d", msg->ack_msg.blk_num, blk_num);
if (blk_num == 0) {
continue;
}
}
sendlen = cftp_send_data_retry(desc, data_msg, sizeof(*data_msg) + readlen, desc->retry_count);
if (sendlen < 0) {
pr_err_info("cftp_send_data_retry");
goto out_free_data_msg;
}
break;
default:
pr_err_info("invalid package type");
cftp_send_error_message(desc, (struct cftp_error_message *) msg, "invalid package type");
ret = -EINVAL;
goto out_free_data_msg;
}
}
out_free_data_msg:
free(data_msg);
out_close_file:
close(fd);
out_free_msg:
free(msg);
return ret;
}
int
TextTest(int verbose, struct cfg *cfg, char *args[])
{
tchar buf[1024];
tchar *hello = TEXT("hello");
tchar *a = TEXT("a");
tchar *e = TEXT("");
tchar *cpy;
cfg = NULL; *args = NULL; verbose = 1;
/* text_length */
T(text_length(NULL, NULL) == 0);
T(text_length(hello, NULL) == 0);
T(text_length(hello + 3, hello) == 0);
T(text_length(hello, hello) == 0);
T(text_length(hello, hello + 1) == 0);
T(text_length(hello, hello + 4) == 0);
T(text_length(a, a + 1) == 0);
T(text_length(a, a + 2) == 1);
T(text_length(a + 1, a + 2) == 0);
T(text_length(hello, hello + 100) == 5);
/* text_size */
T(text_size(NULL, NULL) == 0);
T(text_size(hello, NULL) == 0);
T(text_size(hello + 3, hello) == 0);
T(text_size(hello, hello) == 0);
T(text_size(hello, hello + 1) == 0);
T(text_size(hello, hello + 4) == 0);
T(text_size(a, a + 1) == 0);
T(text_size(a, a + 2) == (2 * sizeof *a));
T(text_size(a + 1, a + 2) == (1 * sizeof *a));
T(text_size(hello, hello + 100) == (6 * sizeof *hello));
/* text_copy */
T(text_copy(hello, hello + 100, NULL, buf + 1024, 0) == 0);
T(text_copy(hello, hello + 100, buf + 3, buf, 0) == 0);
memset(buf, 'x', 1024 * sizeof(tchar));
T(text_copy(NULL, hello + 100, buf, buf + 1024, 0) == 0);
T(buf[0] == TEXT('\0'));
memset(buf, 'x', 1024 * sizeof(tchar));
T(text_copy(hello + 3, hello, buf, buf + 1024, 0) == 0);
T(buf[0] == TEXT('\0'));
memset(buf, 'x', 1024 * sizeof(tchar));
T(text_copy(hello, hello + 100, buf, buf + 100, 1) == 1);
T(tcsncmp(TEXT("h"), buf, 100) == 0);
memset(buf, 'x', 1024 * sizeof(tchar));
T(text_copy(hello, hello + 100, buf, buf + 100, 5) == 5);
T(tcsncmp(hello, buf, 100) == 0);
memset(buf, 'x', 1024 * sizeof(tchar));
T(text_copy(hello, hello + 100, buf, buf + 1024, 0) == 0);
T(buf[0] == TEXT('\0'));
memset(buf, 'x', 1024 * sizeof(tchar));
T(text_copy(e, e + 100, buf, buf + 1024, 100) == 0);
T(tcsncmp(e, buf, 100) == 0);
memset(buf, 'x', 1024 * sizeof(tchar));
T(text_copy(hello, hello + 100, buf, buf + 1024, 100) == 5);
T(tcsncmp(hello, buf, 100) == 0);
memset(buf, 'x', 1024 * sizeof(tchar));
T(text_copy(hello, hello + 1, buf, buf + 1024, 100) == 0);
T(buf[0] == TEXT('\0'));
memset(buf, 'x', 1024 * sizeof(tchar));
T(text_copy(hello, hello + 5, buf, buf + 1024, 100) == 0);
T(buf[0] == TEXT('\0'));
memset(buf, 'x', 1024 * sizeof(tchar));
T(text_copy(hello, hello + 6, buf, buf + 1024, 100) == 5);
T(tcsncmp(hello, buf, 100) == 0);
memset(buf, 'x', 1024 * sizeof(tchar));
T(text_copy(hello, hello + 100, buf, buf + 1, 100) == 0);
T(buf[0] == TEXT('\0'));
memset(buf, 'x', 1024 * sizeof(tchar));
T(text_copy(hello, hello + 100, buf, buf + 5, 100) == 0);
T(buf[0] == TEXT('\0'));
memset(buf, 'x', 1024 * sizeof(tchar));
T(text_copy(hello, hello + 100, buf, buf + 6, 100) == 5);
T(tcsncmp(hello, buf, 100) == 0);
/* text_copy_new */
T(text_copy_new(hello, hello + 100, &cpy, 100, NULL) == 5);
T(tcsncmp(hello, cpy, 100) == 0);
allocator_free(NULL, cpy);
T(text_copy_new(hello, hello + 100, NULL, 100, NULL) == 0);
T(text_copy_new(NULL, hello + 100, &cpy, 100, NULL) == 0);
T(cpy == NULL);
T(text_copy_new(hello + 3, hello, &cpy, 100, NULL) == 0);
T(cpy == NULL);
T(text_copy_new(hello, hello + 100, &cpy, 0, NULL) == 0);
T(tcsncmp(e, cpy, 100) == 0);
allocator_free(NULL, cpy);
T(text_copy_new(hello, hello + 100, &cpy, 4, NULL) == 4);
T(tcsncmp(TEXT("hell"), cpy, 100) == 0);
allocator_free(NULL, cpy);
T(text_copy_new(hello, hello + 100, &cpy, 5, NULL) == 5);
T(tcsncmp(hello, cpy, 100) == 0);
allocator_free(NULL, cpy);
return 0;
}
// Parse info string into server name, players, maxplayers
// Warning! Modifies string!
static void update_serverlist_server (m_serverlist_server_t *server, char *info, int ping)
{
char *s;
const char *servername;
// start at end of string:
s = strlen(info) + info;
// find max players
while(s > info && *s != '/')
s--;
server->maxplayers = atoi(s+1);
// find current number of players:
*s = 0;
s--;
while(s > info && *s >= '0' && *s <= '9')
s--;
server->players = atoi(s+1);
// find map name:
while(s > info && *s == 32) // clear whitespace;
s--;
*(s + 1) = 0;
while(s > info && *s > 32)
s--;
if (!server->mapname)
{
server->mapname = text_copy(s + 1);
}
else if (!Q_streq(server->mapname, s + 1))
{
char buf[MAX_QPATH];
Z_Free(server->mapname);
sprintf(buf, "%s/maps/%s.bsp", FS_Gamedir(), s + 1);
if (!FileExists(buf))
{
// put maps clients don't have in italics
sprintf(buf, "%c%s%c", SCHAR_ITALICS, s + 1, SCHAR_ITALICS);
server->mapname = text_copy(buf);
}
else
{
server->mapname = text_copy(s+1);
}
}
// servername is what's left over:
*s = 0;
servername = info;
while (*servername == ' ') // skip leading spaces
++servername;
if (!server->servername || strlen(server->servername) < strlen(servername))
{
if (server->servername)
Z_Free(server->servername);
server->servername = text_copy(servername);
}
strip_garbage(server->servername, servername);
// and the ping
server->ping = ping;
}
void M_AddToServerList (netadr_t adr, char *info, qboolean pinging)
{
int i;
char addrip[32];
int ping;
qboolean added = false;
NetAdrToString(adr, addrip, sizeof(addrip));
pthread_mutex_lock(&m_mut_serverlist); // jitmultithreading -- todo, deadlock
pthread_mutex_lock(&m_mut_widgets);
// check if server exists in current serverlist:
for (i = 0; i < m_serverlist.numservers; i++)
{
if (adrs_equal(adr, m_serverlist.server[i].adr))
{
// update info from server:
if (pinging)
{
set_serverlist_server_pingtime(&m_serverlist.server[i], Sys_Milliseconds());
}
else
{
ping = Sys_Milliseconds() - m_serverlist.server[i].ping_request_time;
update_serverlist_server(&m_serverlist.server[i], info, ping);
if (m_serverlist.server[i].remap < 0)
{
m_serverlist.server[i].remap = m_serverlist.nummapped++;
m_serverlist.ips[m_serverlist.server[i].remap] = text_copy(addrip);
}
else
{
Z_Free(m_serverlist.info[m_serverlist.server[i].remap]);
}
m_serverlist.info[m_serverlist.server[i].remap] =
text_copy(format_info_from_serverlist_server(&m_serverlist.server[i]));
}
added = true;
break;
}
}
if (!added) // doesn't exist. Add it.
{
i++;
// List too big? Alloc more memory:
// STL would be useful about now
if (i > m_serverlist.actualsize)
{
char **tempinfo;
char **tempips;
m_serverlist_server_t *tempserver;
// Double the size:
tempinfo = Z_Malloc(sizeof(char*) * m_serverlist.actualsize * 2);
tempips = Z_Malloc(sizeof(char*) * m_serverlist.actualsize * 2);
tempserver = Z_Malloc(sizeof(m_serverlist_server_t) * m_serverlist.actualsize * 2);
for(i = 0; i < m_serverlist.actualsize; i++)
{
tempinfo[i] = m_serverlist.info[i];
tempips[i] = m_serverlist.ips[i];
tempserver[i] = m_serverlist.server[i];
}
for (i = m_serverlist.actualsize; i < m_serverlist.actualsize * 2; i++)
{
memset(&tempserver[i], 0, sizeof(m_serverlist_server_t));
tempserver[i].remap = -1;
}
Z_Free(m_serverlist.info);
Z_Free(m_serverlist.ips);
Z_Free(m_serverlist.server);
m_serverlist.info = tempinfo;
m_serverlist.ips = tempips;
m_serverlist.server = tempserver;
m_serverlist.actualsize *= 2;
}
m_serverlist.server[m_serverlist.numservers].adr = adr; // jitodo - test
// add data to serverlist:
if (pinging)
{
set_serverlist_server_pingtime(&m_serverlist.server[m_serverlist.numservers], Sys_Milliseconds());
ping = 999;
update_serverlist_server(&m_serverlist.server[m_serverlist.numservers], info, ping);
}
else
{
// this will probably only happen with LAN servers.
ping = Sys_Milliseconds() - m_serverPingSartTime;
m_serverlist.ips[m_serverlist.nummapped] = text_copy(addrip);
update_serverlist_server(&m_serverlist.server[m_serverlist.numservers], info, ping);
m_serverlist.info[m_serverlist.nummapped] =
text_copy(format_info_from_serverlist_server(&m_serverlist.server[m_serverlist.numservers]));
m_serverlist.server[m_serverlist.numservers].remap = m_serverlist.nummapped;
m_serverlist.nummapped++;
}
m_serverlist.numservers++;
}
m_serverlist.sortthisframe = true;
// Tell the widget the serverlist has updated:
pthread_mutex_unlock(&m_mut_widgets);
//M_RefreshActiveMenu(); // jitodo - target serverlist window specifically.
M_RefreshWidget("serverlist", false);
pthread_mutex_unlock(&m_mut_serverlist); // jitmultithreading
}
static qboolean serverlist_load (void)
{
int size;
char *data;
char *ptr;
size = FS_LoadFile("serverlist.dat", (void**)&data);
if (size > -1)
{
int endiantest;
int actualsize;
register int i;
// Check header to make sure it's a valid file:
if (memcmp(data, "PB2Serverlist1.00", sizeof("PB2Serverlist1.00")-1) != 0)
{
FS_FreeFile(data);
return false;
}
ptr = data + sizeof("PB2Serverlist1.00")-1;
memcpy(&endiantest, ptr, sizeof(int));
if (endiantest != 123123123)
{
FS_FreeFile(data);
return false;
}
// Read our data:
ptr += sizeof(int);
memcpy(&actualsize, ptr, sizeof(int));
if (actualsize < INITIAL_SERVERLIST_SIZE)
{
FS_FreeFile(data);
return false;
}
ptr += sizeof(int);
create_serverlist(actualsize);
memcpy(&m_serverlist.numservers, ptr, sizeof(int));
ptr += sizeof(int);
memcpy(&m_serverlist.nummapped, ptr, sizeof(int));
ptr += sizeof(int);
for (i=0; i<m_serverlist.numservers; i++)
{
memcpy(&m_serverlist.server[i].adr, ptr, sizeof(netadr_t));
ptr += sizeof(netadr_t);
m_serverlist.server[i].remap = *(short*)ptr;
ptr += sizeof(short);
m_serverlist.server[i].servername = text_copy(ptr);
ptr = skip_string(ptr);
m_serverlist.server[i].mapname = text_copy(ptr);
ptr = skip_string(ptr);
m_serverlist.server[i].ping = *(unsigned short*)ptr;
ptr += sizeof(unsigned short);
m_serverlist.server[i].players = *(unsigned char*)ptr;
ptr += sizeof(unsigned char);
m_serverlist.server[i].maxplayers = *(unsigned char*)ptr;
ptr += sizeof(unsigned char);
}
for (i=0; i<m_serverlist.nummapped; i++)
{
m_serverlist.ips[i] = text_copy(ptr);
ptr = skip_string(ptr);
m_serverlist.info[i] = text_copy(ptr);
ptr = skip_string(ptr);
}
FS_FreeFile(data);
return true;
}
return false;
}
int ext2_find_file(struct ext2_desc *desc, const char *pathname, struct ext2_inode *inode)
{
struct ext2_directory_entry entry;
char path_temp[1024], *filename, *p;
text_copy(path_temp, pathname);
filename = p = path_temp;
entry.inode = 2;
entry.file_type = EXT_FILE_TYPE_DIRECTORY;
while (1)
{
int ret;
ssize_t rdlen;
rdlen = ext2_read_inode(desc, entry.inode, inode);
if (rdlen < 0)
{
print_error("ext2_read_inode");
return rdlen;
}
#if CAVAN_EXT2_DEBUG
show_ext2_inode(inode);
#endif
while (*filename == '/')
{
filename++;
}
if (*filename == 0)
{
break;
}
if (entry.file_type != EXT_FILE_TYPE_DIRECTORY)
{
ERROR_RETURN(ENOENT);
}
for (p = filename; *p && *p != '/'; p++);
*p = 0;
if (inode->flags & EXT2_INODE_FLAG_EXTENTS)
{
ret = ext4_find_file_base(desc, filename, (struct ext4_extent_header *) inode->block, &entry);
}
else
{
ret = ext2_find_file_base(desc, filename, inode->block, inode->blocks, &entry);
}
if (ret < 0)
{
ERROR_RETURN(ENOENT);
}
filename = p + 1;
}
return 0;
}
