diff options
Diffstat (limited to 'src/usf/psftag.c')
| -rw-r--r-- | src/usf/psftag.c | 528 |
1 files changed, 0 insertions, 528 deletions
diff --git a/src/usf/psftag.c b/src/usf/psftag.c deleted file mode 100644 index 5665552..0000000 --- a/src/usf/psftag.c +++ /dev/null @@ -1,528 +0,0 @@ -
-/////////////////////////////////////////////////////////////////////////////
-//
-// tag handling
-//
-/////////////////////////////////////////////////////////////////////////////
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "psftag.h"
-
-#if !defined(__WIN32__) && !defined(_MSC_VER)
-#include <unistd.h>
-#else
-#include <windows.h>
-static void truncate(const char *filename, int size) {
-
- HANDLE f = CreateFile(
- filename,
- GENERIC_WRITE,
- 0,
- NULL,
- OPEN_EXISTING,
- FILE_ATTRIBUTE_NORMAL,
- NULL
- );
- if(f == INVALID_HANDLE_VALUE) return;
- SetFilePointer(f, size, NULL, FILE_BEGIN);
- if(GetLastError() == NO_ERROR) SetEndOfFile(f);
- CloseHandle(f);
-}
-#endif
-
-/////////////////////////////////////////////////////////////////////////////
-/*
-** Returns index, or -1 if not found
-** Returns the index starting at the first non-whitespace character of
-** the actual variable name
-*/
-static int find_tag_var_start(const char *tagbuffer, const char *varname) {
- int i, j;
- if(!tagbuffer || !varname) return -1;
- for(i = 0;;) {
- /*
- ** Find first non-whitespace
- ** (this is the variable name on the current line)
- */
- for(;; i++) {
- unsigned u = ((unsigned)(tagbuffer[i])) & 0xFF;
- /* If the tag ends here, we wouldn't have had any data anyway */
- if(!u) return -1;
- if(u <= 0x20) continue;
- break;
- }
- /*
- ** Compare case-insensitively to the var name
- */
- for(j = 0;; j++) {
- unsigned ucmp = ((unsigned)(varname [ j])) & 0xFF;
- unsigned u = ((unsigned)(tagbuffer[i + j])) & 0xFF;
- /* if the varname ends, we'll break here and do the equals check */
- if(!ucmp) break;
- /* If the tag ends here, we wouldn't have had any data anyway */
- if(!u) return -1;
- /* lowercase */
- if(ucmp >= 'A' && ucmp <= 'Z') { ucmp -= 'A'; ucmp += 'a'; }
- if(u >= 'A' && u <= 'Z') { u -= 'A'; u += 'a'; }
- /* if they're unequal, break... */
- if(u != ucmp) break;
- }
- /*
- ** Only if we exhausted the varname will we do the equals check
- */
- if(!varname[j]) {
- /*
- ** Ensure that the next non-whitespace character in [i+j] is an '='
- */
- for(;; j++) {
- unsigned u = ((unsigned)(tagbuffer[i + j])) & 0xFF;
- /* If the tag ends here, we wouldn't have had any data anyway */
- if(!u) return -1;
- /* quit at the first '=' - success! */
- if(u == '=') return i;
- /* shouldn't be a newline here! */
- if(u == 0x0A) break;
- /* ignore whitespace */
- if(u <= 0x20) continue;
- /* any other character is an error */
- break;
- }
- }
- i += j + 1;
- /*
- ** Find newline or end-of-tag
- */
- for(;; i++) {
- unsigned u = ((unsigned)(tagbuffer[i])) & 0xFF;
- /* If the tag ends here, we wouldn't have had any data anyway */
- if(!u) return -1;
- if(u == 0x0A) break;
- }
- }
- return -1;
-}
-
-/*
-** Returns the index at which the current variable ends
-** (Includes any ending newline and possibly whitespace after that)
-**
-** Buffer points to the first non-whitespace character of the variable name
-*/
-static int find_tag_var_end(const char *tagbuffer) {
- int i, j;
- if(!tagbuffer) return 0;
- for(i = 0;;) {
- /*
- ** Find first non-whitespace
- ** (this is the variable name on the current line)
- */
- for(;; i++) {
- unsigned u = ((unsigned)(tagbuffer[i])) & 0xFF;
- if(!u) return i;
- if(u <= 0x20) continue;
- break;
- }
- /*
- ** Compare case-insensitively to the original var name
- */
- for(j = 0;; j++) {
- unsigned ucmp = ((unsigned)(tagbuffer[ j])) & 0xFF;
- unsigned u = ((unsigned)(tagbuffer[i + j])) & 0xFF;
- /* If the tag ends here, we wouldn't have had any data anyway */
- if(!u) return i;
- /* lowercase */
- if(ucmp >= 'A' && ucmp <= 'Z') { ucmp -= 'A'; ucmp += 'a'; }
- if(u >= 'A' && u <= 'Z') { u -= 'A'; u += 'a'; }
- /* if they're both whitespace or '=', we win */
- if((u <= 0x20 || u == '=') && (ucmp <= 0x20 || ucmp == '=')) break;
- /* if they're unequal, we lose */
- if(u != ucmp) return i;
- /* otherwise, keep trying */
- }
- /*
- ** Ensure that the next non-whitespace character in [i+j] is an '='
- */
- for(;; j++) {
- unsigned u = ((unsigned)(tagbuffer[i + j])) & 0xFF;
- if(!u) return i;
- /* quit at the first '=' */
- if(u == '=') break;
- /* shouldn't be a newline here! */
- if(u == 0x0A) return i;
- /* ignore whitespace */
- if(u <= 0x20) continue;
- /* any other character is an error */
- break;
- }
- i += j + 1;
- /*
- ** Find newline or end-of-tag
- */
- for(;; i++) {
- unsigned u = ((unsigned)(tagbuffer[i])) & 0xFF;
- if(!u) return i;
- if(u == 0x0A) break;
- }
- }
-}
-
-/////////////////////////////////////////////////////////////////////////////
-/*
-** Get tag variable
-** The destination value buffer must be as big as the entire tag
-*/
-int psftag_raw_getvar(
- const char *tag,
- const char *variable,
- char *value_out,
- int value_out_size
-) {
- char *v = value_out;
- char *vmax = v + value_out_size;
- char *v_linebegin;
- int i, i_end;
- //
- // Safety check
- //
- if(value_out_size < 1) return -1;
- /*
- ** Default to empty string
- */
- *v = 0;
- /*
- ** Find the variable start/end index
- */
- i = find_tag_var_start(tag, variable);
- if(i < 0) return -1;
- i_end = i + find_tag_var_end(tag + i);
- /*
- ** Extract the variable data
- */
- while(i < i_end) {
- /*
- ** Skip to first '='
- */
- while((tag[i] != '=') && (i < i_end)) { i++; }
- if(i >= i_end) break;
- /*
- ** If this is not the first line, add a newline
- */
- if(v > value_out) {
- if(v < vmax) { *v++ = 0x0A; }
- }
- /*
- ** Now that we're at a '=', skip past it
- */
- i++;
- if(i >= i_end) break;
- /*
- ** Skip past any whitespace except newlines
- */
- for(; i < i_end; i++) {
- unsigned u = ((unsigned)(tag[i])) & 0xFF;
- if(u == 0x0A) break;
- if(u <= 0x20) continue;
- break;
- }
- if(i >= i_end) break;
- /*
- ** Consume line data
- */
- v_linebegin = v;
- while(i < i_end) {
- unsigned u = ((unsigned)(tag[i++])) & 0xFF;
- if(u == 0x0A) break;
- if(v < vmax) { *v++ = u; }
- }
- /*
- ** Eat end-of-line whitespace
- */
- while(v > v_linebegin && (((unsigned)(v[-1]))&0xFF) <= 0x20) {
- v--;
- }
- }
- /*
- ** Set variable end
- */
- if(v >= vmax) { v = vmax - 1; }
- *v = 0;
- return 0;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-
-void psftag_raw_setvar(
- char *tag,
- int tag_max_size,
- const char *variable,
- const char *value
-) {
- int tag_l = strlen(tag);
- int i, i_end, z;
- int insert_i;
- int insert_l;
- int value_exists = 0;
- int tag_max_usable_size = tag_max_size - 1;
- //
- // Safety check
- //
- if(tag_max_size < 1) return;
- //
- // We will assume we can at least use what's there
- //
- if(tag_max_usable_size < tag_l) {
- tag_max_usable_size = tag_l;
- tag_max_size = tag_l + 1;
- }
- /*
- ** Determine the insertion length of the new variable
- */
- { const char *v;
- int nl = strlen(variable);
- insert_l = nl + 2;
- for(v = value; *v; v++) {
- insert_l++;
- if(*v == 0x0A) {
- /* Value exists if it's multi-line */
- value_exists = 1;
- insert_l += nl + 1;
- } else if((((unsigned)(*v))&0xFF) > 0x20) {
- /* Value exists if there are non-whitespace characters */
- value_exists = 1;
- }
- }
- }
- /*
- ** If the value is blank, force the insert length to zero
- */
- if(!value_exists) insert_l = 0;
- /*
- ** Find the variable start index
- */
- i = find_tag_var_start(tag, variable);
- /*
- ** If not found, add a new variable
- */
- if(i < 0) {
- /* Insert position is at the end */
- insert_i = tag_l;
- /* Eat trailing whitespace in the file */
- while(insert_i && (((unsigned)(tag[insert_i - 1]))&0xFF) <= 0x20) { insert_i--; }
- /* Insert a newline if there's room and if there's stuff before */
- if(insert_i && (insert_i < tag_max_usable_size)) { tag[insert_i++] = 0x0A; }
- /* Clamp insert length */
- if((insert_i + insert_l) > tag_max_usable_size) { insert_l = tag_max_usable_size - insert_i; }
- z = insert_i + insert_l;
- /*
- ** Otherwise, find the variable end index
- */
- } else {
- int movel;
- insert_i = i;
- /* Clamp insert length */
- if((insert_i + insert_l) > tag_max_usable_size) { insert_l = tag_max_usable_size - insert_i; }
- i_end = i + find_tag_var_end(tag + i);
- /* Move remaining file data */
- movel = tag_l - i_end;
- if(movel > (tag_max_usable_size-(insert_i+insert_l))) { movel = tag_max_usable_size - (insert_i+insert_l); }
- /* perform the move */
- if(movel && ((insert_i+insert_l) != i_end)) {
- memmove(tag+insert_i+insert_l, tag+i_end, movel);
- }
- z = insert_i+insert_l+movel;
- }
- /* Add terminating null ahead of time */
- if(z > tag_max_usable_size) z = tag_max_usable_size;
- tag[z] = 0;
- /*
- ** Write the variable to index insert_i, max length insert_l
- */
- insert_l += insert_i;
- while(insert_i < insert_l) {
- const char *v;
- for(v = variable; (*v) && (insert_i < insert_l); v++) {
- tag[insert_i++] = *v;
- }
- if(insert_i >= insert_l) break;
- tag[insert_i++] = '=';
- if(insert_i >= insert_l) break;
- for(; (*value) && ((*value) != 0x0A) && (insert_i < insert_l); value++) {
- tag[insert_i++] = *value;
- }
- if(insert_i >= insert_l) break;
- tag[insert_i++] = 0x0A;
- if(insert_i >= insert_l) break;
- if(!(*value)) break;
- if((*value) == 0x0A) value++;
- }
-
-}
-
-/////////////////////////////////////////////////////////////////////////////
-
-#define TAGMAX (50000)
-#define ERRORMAX (256)
-
-struct PSFTAG {
- char str[TAGMAX + 1];
-};
-
-/*void *psftag_create(void) {
- struct PSFTAG *p = malloc(sizeof(struct PSFTAG));
- if(!p) return NULL;
- p->str[0] = 0;
- //p->errorstring[0] = 0;
- return p;
-}
-
-void psftag_delete(void *psftag) {
- free(psftag);
-}*/
-
-/////////////////////////////////////////////////////////////////////////////
-
-/*const char *psftag_getlasterror(void *psftag) {
- return ((struct PSFTAG*)psftag)->errorstring;
-}*/
-
-/////////////////////////////////////////////////////////////////////////////
-
-void psftag_getraw(void *psftag, char *raw_out, int raw_out_size) {
- if(raw_out_size < 1) return;
- strncpy(raw_out, ((struct PSFTAG*)psftag)->str, raw_out_size);
- raw_out[raw_out_size - 1] = 0;
-}
-
-void psftag_setraw(void *psftag, const char *raw_in) {
- strncpy(((struct PSFTAG*)psftag)->str, raw_in, TAGMAX + 1);
- ((struct PSFTAG*)psftag)->str[TAGMAX] = 0;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-
-int psftag_getvar(void *psftag, const char *variable, char *value_out, int value_out_size) {
- return psftag_raw_getvar(((struct PSFTAG*)psftag)->str, variable, value_out, value_out_size);
-}
-
-void psftag_setvar(void *psftag, const char *variable, const char *value) {
- psftag_raw_setvar(((struct PSFTAG*)psftag)->str, TAGMAX + 1, variable, value);
-}
-
-/////////////////////////////////////////////////////////////////////////////
-
-int psftag_readfromfile(void *psftag, const char *path) {
- struct PSFTAG *t = (struct PSFTAG*)psftag;
- FILE *f = NULL;
- int l;
- int rsize, exesize, tagstart;
- char hdr[12];
-
- f = fopen(path, "rb");
- if(!f) {
- //strncpy(t->errorstring, strerror(errno), ERRORMAX);
- //t->errorstring[ERRORMAX-1] = 0;
- return -1;
- }
-
- if(fread(hdr, 1, 12, f) != 12) goto invalidformat;
- if(memcmp(hdr, "PSF", 3)) goto invalidformat;
-
- rsize =
- ((((unsigned)(hdr[ 4])) & 0xFF) << 0) |
- ((((unsigned)(hdr[ 5])) & 0xFF) << 8) |
- ((((unsigned)(hdr[ 6])) & 0xFF) << 16) |
- ((((unsigned)(hdr[ 7])) & 0xFF) << 24);
- exesize =
- ((((unsigned)(hdr[ 8])) & 0xFF) << 0) |
- ((((unsigned)(hdr[ 9])) & 0xFF) << 8) |
- ((((unsigned)(hdr[10])) & 0xFF) << 16) |
- ((((unsigned)(hdr[11])) & 0xFF) << 24);
-
- tagstart = 16 + rsize + exesize;
-
- fseek(f, tagstart, SEEK_SET);
-
- if(fread(hdr, 1, 5, f) != 5) goto notpresent;
- if(memcmp(hdr, "[TAG]", 5)) goto invalidformat;
-
- tagstart += 5;
- fseek(f, 0, SEEK_END);
- l = ftell(f);
- fseek(f, tagstart, SEEK_SET);
- l -= tagstart;
- if(l < 0) l = 0;
- if(l > TAGMAX) l = TAGMAX;
-
- memset(t->str, 0, TAGMAX + 1);
- fread(t->str, 1, l, f);
-
- fclose(f);
- return 0;
-
-invalidformat:
-// strcpy(t->errorstring, "Invalid file format");
- goto error;
-notpresent:
-// strcpy(t->errorstring, "Tag not present");
- goto error;
-error:
- if(f) fclose(f);
- return -1;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-
-int psftag_writetofile(void *psftag, const char *path) {
- struct PSFTAG *t = (struct PSFTAG*)psftag;
- FILE *f = NULL;
- int l;
- int rsize, exesize, tagstart;
- char hdr[12];
-
- f = fopen(path, "r+b");
- if(!f) {
- //strncpy(t->errorstring, strerror(errno), ERRORMAX);
- //t->errorstring[ERRORMAX-1] = 0;
- return -1;
- }
-
- if(fread(hdr, 1, 12, f) != 12) goto invalidformat;
- if(memcmp(hdr, "PSF", 3)) goto invalidformat;
-
- rsize =
- ((((unsigned)(hdr[ 4])) & 0xFF) << 0) |
- ((((unsigned)(hdr[ 5])) & 0xFF) << 8) |
- ((((unsigned)(hdr[ 6])) & 0xFF) << 16) |
- ((((unsigned)(hdr[ 7])) & 0xFF) << 24);
- exesize =
- ((((unsigned)(hdr[ 8])) & 0xFF) << 0) |
- ((((unsigned)(hdr[ 9])) & 0xFF) << 8) |
- ((((unsigned)(hdr[10])) & 0xFF) << 16) |
- ((((unsigned)(hdr[11])) & 0xFF) << 24);
-
- tagstart = 16 + rsize + exesize;
-
- fseek(f, tagstart, SEEK_SET);
-
- l = strlen(t->str);
-
- fwrite("[TAG]", 1, 5, f);
- fwrite(t->str, 1, l, f);
- fclose(f);
-
- truncate(path, tagstart + 5 + l);
-
- return 0;
-
-invalidformat:
-// strcpy(t->errorstring, "Invalid file format");
- goto error;
-error:
- if(f) fclose(f);
- return -1;
-}
-
-/////////////////////////////////////////////////////////////////////////////
|