/** @copydoc socket_command_struct::handle_func */
void socket_command_file_update(uint8_t *data, size_t len, size_t pos)
{
char filename[MAX_BUF];
unsigned long ucomp_len;
unsigned char *dest;
FILE *fp;
if (file_updates_requested != 0) {
file_updates_requested--;
}
packet_to_string(data, len, &pos, filename, sizeof(filename));
ucomp_len = packet_to_uint32(data, len, &pos);
len -= pos;
/* Uncompress it. */
dest = emalloc(ucomp_len);
uncompress((Bytef *) dest, (uLongf *) & ucomp_len, (const Bytef *) data + pos, (uLong) len);
data = dest;
len = ucomp_len;
fp = path_fopen(filename, "wb");
if (!fp) {
LOG(BUG, "Could not open file '%s' for writing.", filename);
efree(dest);
return;
}
/* Update the file. */
fwrite(data, 1, len, fp);
fclose(fp);
efree(dest);
}
bool path_read_binary(const string& path, vector<uint8_t>& binary)
{
/* read binary file into memory */
FILE *f = path_fopen(path, "rb");
if(!f) {
binary.resize(0);
return false;
}
binary.resize(path_file_size(path));
if(binary.size() == 0) {
fclose(f);
return false;
}
if(fread(&binary[0], sizeof(uint8_t), binary.size(), f) != binary.size()) {
fclose(f);
return false;
}
fclose(f);
return true;
}
/**
* Parse the updates srv file, and request updated files as needed.
*/
void file_updates_parse(void)
{
FILE *fp;
char buf[HUGE_BUF];
/* Is the feature disabled? */
if (setting_get_int(OPT_CAT_CLIENT, OPT_DISABLE_FILE_UPDATES)) {
return;
}
fp = server_file_open_name(SERVER_FILE_UPDATES);
if (!fp) {
return;
}
while (fgets(buf, sizeof(buf) - 1, fp)) {
char filename[MAX_BUF], crc_buf[MAX_BUF], *contents;
uint64_t size;
size_t st_size, numread;
FILE *fp2;
unsigned long crc;
struct stat sb;
if (sscanf(buf, "%s %"PRIu64 " %s", filename, &size, crc_buf) != 3) {
continue;
}
fp2 = path_fopen(filename, "rb");
/* No such file? Then we'll want to update this. */
if (!fp2) {
file_updates_request(filename);
continue;
}
fstat(fileno(fp2), &sb);
st_size = sb.st_size;
contents = emalloc(st_size);
numread = fread(contents, 1, st_size, fp2);
fclose(fp2);
/* Get the CRC32... */
crc = crc32(1L, (const unsigned char FAR *) contents, numread);
efree(contents);
/* If the checksum or the size doesn't match, we'll want to update it.
* */
if (crc != strtoul(crc_buf, NULL, 16) || st_size != (size_t) size) {
file_updates_request(filename);
}
}
fclose(fp);
}
int ipc_sem_get_limits(struct ipc_limits *lim)
{
FILE *f;
int rc = 0;
lim->semvmx = SEMVMX;
f = path_fopen("r", 0, _PATH_PROC_IPC_SEM);
if (f) {
rc = fscanf(f, "%d\t%d\t%d\t%d",
&lim->semmsl, &lim->semmns, &lim->semopm, &lim->semmni);
fclose(f);
}
if (rc == 4) {
struct seminfo seminfo;
union semun arg = { .array = (ushort *) &seminfo };
if (semctl(0, 0, IPC_INFO, arg) < 0)
return 1;
lim->semmni = seminfo.semmni;
lim->semmsl = seminfo.semmsl;
lim->semmns = seminfo.semmns;
lim->semopm = seminfo.semopm;
}
return 0;
}
int ipc_shm_get_limits(struct ipc_limits *lim)
{
lim->shmmin = SHMMIN;
if (path_exist(_PATH_PROC_IPC_SHMALL) &&
path_exist(_PATH_PROC_IPC_SHMMAX) &&
path_exist(_PATH_PROC_IPC_SHMMNI)) {
lim->shmall = path_read_u64(_PATH_PROC_IPC_SHMALL);
lim->shmmax = path_read_u64(_PATH_PROC_IPC_SHMMAX);
lim->shmmni = path_read_u64(_PATH_PROC_IPC_SHMMNI);
} else {
struct shminfo shminfo;
if (shmctl(0, IPC_INFO, (struct shmid_ds *) &shminfo) < 0)
return 1;
lim->shmmni = shminfo.shmmni;
lim->shmall = shminfo.shmall;
}
return 0;
}
bool path_write_binary(const string& path, const vector<uint8_t>& binary)
{
path_create_directories(path);
/* write binary file from memory */
FILE *f = path_fopen(path, "wb");
if(!f)
return false;
if(binary.size() > 0)
fwrite(&binary[0], sizeof(uint8_t), binary.size(), f);
fclose(f);
return true;
}
/**
* Save the blacklist data to file.
* @param list
* The music list.
*/
static void mplayer_blacklist_save(list_struct *list)
{
FILE *fp;
size_t row;
fp = path_fopen(FILE_MPLAYER_BLACKLIST, "w");
if (fp == NULL) {
LOG(ERROR, "Failed to open file: %s",
FILE_MPLAYER_BLACKLIST);
return;
}
for (row = 0; row < list->rows; row++) {
if (shuffle_blacklist[row]) {
fprintf(fp, "%s\n", list->text[row][0]);
}
}
fclose(fp);
}
bool MD5Hash::append_file(const string& filepath)
{
FILE *f = path_fopen(filepath, "rb");
if(!f) {
fprintf(stderr, "MD5: failed to open file %s\n", filepath.c_str());
return false;
}
const size_t buffer_size = 1024;
uint8_t buffer[buffer_size];
size_t n;
do {
n = fread(buffer, 1, buffer_size, f);
append(buffer, n);
} while(n == buffer_size);
bool success = (ferror(f) == 0);
fclose(f);
return success;
}
int ipc_shm_get_info(int id, struct shm_data **shmds)
{
FILE *f;
int i, maxid;
struct shm_data *p;
struct shm_info dummy;
p = *shmds = xcalloc(1, sizeof(struct shm_data));
p->next = NULL;
f = path_fopen("r", 0, _PATH_PROC_SYSV_SHM);
if (!f)
goto fallback;
while (fgetc(f) != '\n'); /* skip header */
while (feof(f) == 0) {
if (fscanf(f,
"%d %d %o %"SCNu64 " %u %u "
"%"SCNu64 " %u %u %u %u %"SCNu64 " %"SCNu64 " %"SCNu64
" %"SCNu64 " %"SCNu64 "\n",
&p->shm_perm.key,
&p->shm_perm.id,
&p->shm_perm.mode,
&p->shm_segsz,
&p->shm_cprid,
&p->shm_lprid,
&p->shm_nattch,
&p->shm_perm.uid,
&p->shm_perm.gid,
&p->shm_perm.cuid,
&p->shm_perm.cgid,
&p->shm_atim,
&p->shm_dtim,
&p->shm_ctim,
&p->shm_rss,
&p->shm_swp) != 16)
continue;
if (id > -1) {
/* ID specified */
if (id == p->shm_perm.id) {
i = 1;
break;
} else
continue;
}
p->next = xcalloc(1, sizeof(struct shm_data));
p = p->next;
p->next = NULL;
i++;
}
if (i == 0)
free(*shmds);
fclose(f);
return i;
/* Fallback; /proc or /sys file(s) missing. */
fallback:
i = id < 0 ? 0 : id;
maxid = shmctl(0, SHM_INFO, (struct shmid_ds *) &dummy);
if (maxid < 0)
return 0;
while (i <= maxid) {
int shmid;
struct shmid_ds shmseg;
struct ipc_perm *ipcp = &shmseg.shm_perm;
shmid = shmctl(i, SHM_STAT, &shmseg);
if (shmid < 0) {
if (-1 < id) {
free(*shmds);
return 0;
}
i++;
continue;
}
p->shm_perm.key = ipcp->KEY;
p->shm_perm.id = shmid;
p->shm_perm.mode = ipcp->mode;
p->shm_segsz = shmseg.shm_segsz;
p->shm_cprid = shmseg.shm_cpid;
p->shm_lprid = shmseg.shm_lpid;
p->shm_nattch = shmseg.shm_nattch;
p->shm_perm.uid = ipcp->uid;
p->shm_perm.gid = ipcp->gid;
p->shm_perm.cuid = ipcp->cuid;
p->shm_perm.cgid = ipcp->cuid;
p->shm_atim = shmseg.shm_atime;
p->shm_dtim = shmseg.shm_dtime;
p->shm_ctim = shmseg.shm_ctime;
p->shm_rss = 0xdead;
p->shm_swp = 0xdead;
if (id < 0) {
p->next = xcalloc(1, sizeof(struct shm_data));
p = p->next;
p->next = NULL;
i++;
} else
return 1;
}
return i;
}
int ipc_msg_get_info(int id, struct msg_data **msgds)
{
FILE *f;
int i, maxid;
struct msg_data *p;
struct msqid_ds dummy;
struct msqid_ds msgseg;
p = *msgds = xcalloc(1, sizeof(struct msg_data));
p->next = NULL;
f = path_fopen("r", 0, _PATH_PROC_SYSV_MSG);
if (!f)
goto msg_fallback;
while (fgetc(f) != '\n') ; /* skip header */
while (feof(f) == 0) {
if (fscanf(f,
"%d %d %o %" SCNu64 " %" SCNu64 " %u %u %u %u %u %u %" SCNu64 " %" SCNu64 " %" SCNu64 "\n",
&p->msg_perm.key,
&p->msg_perm.id,
&p->msg_perm.mode,
&p->q_cbytes,
&p->q_qnum,
&p->q_lspid,
&p->q_lrpid,
&p->msg_perm.uid,
&p->msg_perm.gid,
&p->msg_perm.cuid,
&p->msg_perm.cgid,
&p->q_stime,
&p->q_rtime,
&p->q_ctime) != 14)
continue;
if (id > -1) {
/* ID specified */
if (id == p->msg_perm.id) {
/*
* FIXME: q_qbytes are not in /proc
*
*/
if (msgctl(id, IPC_STAT, &msgseg) != -1)
p->q_qbytes = msgseg.msg_qbytes;
i = 1;
break;
} else
continue;
}
p->next = xcalloc(1, sizeof(struct msg_data));
p = p->next;
p->next = NULL;
i++;
}
if (i == 0)
free(*msgds);
fclose(f);
return i;
/* Fallback; /proc or /sys file(s) missing. */
msg_fallback:
i = id < 0 ? 0 : id;
maxid = msgctl(id, MSG_STAT, &dummy);
if (maxid < 0)
return 0;
while (i <= maxid) {
int msgid;
struct ipc_perm *ipcp = &msgseg.msg_perm;
msgid = msgctl(i, MSG_STAT, &msgseg);
if (msgid < 0) {
if (-1 < id) {
free(*msgds);
return 0;
}
i++;
continue;
}
p->msg_perm.key = ipcp->KEY;
p->msg_perm.id = msgid;
p->msg_perm.mode = ipcp->mode;
p->q_cbytes = msgseg.msg_cbytes;
p->q_qnum = msgseg.msg_qnum;
p->q_lspid = msgseg.msg_lspid;
p->q_lrpid = msgseg.msg_lrpid;
p->msg_perm.uid = ipcp->uid;
p->msg_perm.gid = ipcp->gid;
p->msg_perm.cuid = ipcp->cuid;
p->msg_perm.cgid = ipcp->cgid;
p->q_stime = msgseg.msg_stime;
p->q_rtime = msgseg.msg_rtime;
p->q_ctime = msgseg.msg_ctime;
p->q_qbytes = msgseg.msg_qbytes;
if (id < 0) {
p->next = xcalloc(1, sizeof(struct msg_data));
p = p->next;
p->next = NULL;
i++;
} else
return 1;
}
return i;
}
static void get_sem_elements(struct sem_data *p)
{
size_t i;
if (!p || !p->sem_nsems || p->sem_perm.id < 0)
return;
p->elements = xcalloc(p->sem_nsems, sizeof(struct sem_elem));
for (i = 0; i < p->sem_nsems; i++) {
struct sem_elem *e = &p->elements[i];
union semun arg = { .val = 0 };
e->semval = semctl(p->sem_perm.id, i, GETVAL, arg);
if (e->semval < 0)
err(EXIT_FAILURE, _("%s failed"), "semctl(GETVAL)");
e->ncount = semctl(p->sem_perm.id, i, GETNCNT, arg);
if (e->ncount < 0)
err(EXIT_FAILURE, _("%s failed"), "semctl(GETNCNT)");
e->zcount = semctl(p->sem_perm.id, i, GETZCNT, arg);
if (e->zcount < 0)
err(EXIT_FAILURE, _("%s failed"), "semctl(GETZCNT)");
e->pid = semctl(p->sem_perm.id, i, GETPID, arg);
if (e->pid < 0)
err(EXIT_FAILURE, _("%s failed"), "semctl(GETPID)");
}
}
int ipc_sem_get_info(int id, struct sem_data **semds)
{
FILE *f;
int i, maxid;
struct sem_data *p;
struct seminfo dummy;
union semun arg;
p = *semds = xcalloc(1, sizeof(struct sem_data));
p->next = NULL;
f = path_fopen("r", 0, _PATH_PROC_SYSV_SEM);
if (!f)
goto sem_fallback;
while (fgetc(f) != '\n') ; /* skip header */
while (feof(f) == 0) {
if (fscanf(f,
"%d %d %o %" SCNu64 " %u %u %u %u %" SCNu64 " %" SCNu64 "\n",
&p->sem_perm.key,
&p->sem_perm.id,
&p->sem_perm.mode,
&p->sem_nsems,
&p->sem_perm.uid,
&p->sem_perm.gid,
&p->sem_perm.cuid,
&p->sem_perm.cgid,
&p->sem_otime,
&p->sem_ctime) != 10)
continue;
if (id > -1) {
/* ID specified */
if (id == p->sem_perm.id) {
get_sem_elements(p);
i = 1;
break;
} else
continue;
}
p->next = xcalloc(1, sizeof(struct sem_data));
p = p->next;
p->next = NULL;
i++;
}
if (i == 0)
free(*semds);
fclose(f);
return i;
/* Fallback; /proc or /sys file(s) missing. */
sem_fallback:
i = id < 0 ? 0 : id;
arg.array = (ushort *) (void *)&dummy;
maxid = semctl(0, 0, SEM_INFO, arg);
if (maxid < 0)
return 0;
while (i <= maxid) {
int semid;
struct semid_ds semseg;
struct ipc_perm *ipcp = &semseg.sem_perm;
arg.buf = (struct semid_ds *)&semseg;
semid = semctl(i, 0, SEM_STAT, arg);
if (semid < 0) {
if (-1 < id) {
free(*semds);
return 0;
}
i++;
continue;
}
p->sem_perm.key = ipcp->KEY;
p->sem_perm.id = semid;
p->sem_perm.mode = ipcp->mode;
p->sem_nsems = semseg.sem_nsems;
p->sem_perm.uid = ipcp->uid;
p->sem_perm.gid = ipcp->gid;
p->sem_perm.cuid = ipcp->cuid;
p->sem_perm.cgid = ipcp->cuid;
p->sem_otime = semseg.sem_otime;
p->sem_ctime = semseg.sem_ctime;
if (id < 0) {
p->next = xcalloc(1, sizeof(struct sem_data));
p = p->next;
p->next = NULL;
i++;
} else {
get_sem_elements(p);
return 1;
}
}
return i;
}
/** @copydoc widgetdata::draw_func */
static void widget_draw(widgetdata *widget)
{
SDL_Rect box;
char buf[HUGE_BUF];
size_t i;
/* The list doesn't exist yet, create it. */
if (!list_mplayer) {
char version[MAX_BUF];
/* Create the list and set up settings. */
list_mplayer = list_create(12, 1, 8);
list_mplayer->handle_enter_func = list_handle_enter;
list_mplayer->text_color_hook = list_text_color_hook;
list_mplayer->surface = widget->surface;
list_scrollbar_enable(list_mplayer);
list_set_column(list_mplayer, 0, 130, 7, NULL, -1);
list_set_font(list_mplayer, FONT_ARIAL10);
/* Add default media directory songs. */
get_data_dir_file(buf, sizeof(buf), DIRECTORY_MEDIA);
mplayer_list_init(list_mplayer, buf, 0);
/* Now add custom ones, but ignore duplicates. */
snprintf(buf, sizeof(buf), "%s/.atrinik/%s/"DIRECTORY_MEDIA, get_config_dir(), package_get_version_partial(version, sizeof(version)));
mplayer_list_init(list_mplayer, buf, 1);
/* If we added any, sort the list alphabetically and add an entry
* to disable background music. */
if (list_mplayer->rows) {
FILE *fp;
/* Allocate the blacklist. + 1 is for the last entry added
* further down. It is not actually used by the blacklist as
* it's not possible to toggle it on/off using the button, but
* it simplifies other logic checks. */
shuffle_blacklist = ecalloc(1, sizeof(*shuffle_blacklist) * (list_mplayer->rows + 1));
/* Sort the list. */
list_sort(list_mplayer, LIST_SORT_ALPHA);
/* Read the blacklist file contents. */
fp = path_fopen(FILE_MPLAYER_BLACKLIST, "r");
if (fp) {
size_t row;
while (fgets(buf, sizeof(buf) - 1, fp)) {
for (row = 0; row < list_mplayer->rows; row++) {
if (!strncmp(buf, list_mplayer->text[row][0], strlen(buf) - 1)) {
shuffle_blacklist[row] = 1;
break;
}
}
}
fclose(fp);
}
list_add(list_mplayer, list_mplayer->rows, 0, "Disable music");
}
scrollbar_create(&scrollbar_progress, 130, 11, &scrollbar_progress_info.scroll_offset, &scrollbar_progress_info.num_lines, 1);
scrollbar_progress.redraw = &scrollbar_progress_info.redraw;
}
if (widget->redraw) {
const char *bg_music;
box.h = 0;
box.w = widget->w;
text_show(widget->surface, FONT_SERIF12, "Music Player", 0, 3, COLOR_HGOLD, TEXT_ALIGN_CENTER, &box);
list_set_parent(list_mplayer, widget->x, widget->y);
list_show(list_mplayer, 10, 2);
box.w /= 2;
text_show(widget->surface, FONT_SANS10, "Currently playing:", widget->w / 2, 22, COLOR_WHITE, TEXT_ALIGN_CENTER, &box);
bg_music = sound_get_bg_music_basename();
box.h = 0;
box.w = widget->w / 2;
/* Store the background music file name in temporary buffer and
* make sure it won't overflow by truncating it if necessary. */
if (bg_music) {
strncpy(buf, bg_music, sizeof(buf) - 1);
buf[sizeof(buf) - 1] = '\0';
text_truncate_overflow(FONT_SANS11, buf, 150);
}
/* Show the music that is being played. */
text_show(widget->surface, FONT_SANS11, bg_music ? buf : "No music", widget->w / 2 - 5, 34, COLOR_HGOLD, TEXT_ALIGN_CENTER, &box);
scrollbar_progress.px = widget->x;
scrollbar_progress.py = widget->y;
scrollbar_show(&scrollbar_progress, widget->surface, 170, 50);
box.h = 120;
box.w -= 6 * 2;
text_show(widget->surface, FONT_ARIAL10, "You can use the music player to play your favorite tunes from the game, or play them all one-by-one in random order (shuffle).\n\nNote that if you use the music player, in-game areas won't change your music until you click [b]Stop[/b].", widget->w / 2 + 6, 62, COLOR_WHITE, TEXT_WORD_WRAP | TEXT_MARKUP, &box);
for (i = 0; i < BUTTON_NUM; i++) {
buttons[i].surface = widget->surface;
button_set_parent(&buttons[i], widget->x, widget->y);
}
buttons[BUTTON_PLAY].x = 10;
buttons[BUTTON_PLAY].y = widget->h - TEXTURE_CLIENT("button")->h - 4;
button_show(&buttons[BUTTON_PLAY], sound_map_background(-1) ? "Stop" : "Play");
buttons[BUTTON_SHUFFLE].x = 10 + TEXTURE_CLIENT("button")->w + 5;
buttons[BUTTON_SHUFFLE].y = widget->h - TEXTURE_CLIENT("button")->h - 4;
buttons[BUTTON_SHUFFLE].pressed_forced = shuffle;
button_show(&buttons[BUTTON_SHUFFLE], "Shuffle");
buttons[BUTTON_BLACKLIST].x = 10 + TEXTURE_CLIENT("button")->w * 2 + 5 * 2;
buttons[BUTTON_BLACKLIST].y = widget->h - TEXTURE_CLIENT("button_round")->h - 5;
buttons[BUTTON_BLACKLIST].disabled = list_mplayer->row_selected == list_mplayer->rows;
button_show(&buttons[BUTTON_BLACKLIST], mplayer_blacklisted(list_mplayer) ? "+" : "-");
/* Show close button. */
buttons[BUTTON_CLOSE].x = widget->w - TEXTURE_CLIENT("button_round")->w - 4;
buttons[BUTTON_CLOSE].y = 4;
button_show(&buttons[BUTTON_CLOSE], "X");
/* Show help button. */
buttons[BUTTON_HELP].x = widget->w - TEXTURE_CLIENT("button_round")->w * 2 - 4;
buttons[BUTTON_HELP].y = 4;
button_show(&buttons[BUTTON_HELP], "?");
}
}
