int do_read(int m_fd)
{
const size_t outlength = 80;
char outline[outlength];
char line[80];
const int ret = force_read(m_fd, line, 79);
line[ret] = '\0';
const char * delim = ",";
const char * field0 = strtok(line, delim);
const char * field1 = strtok(NULL, delim);
const char * field2 = strtok(NULL, delim);
const char * field3 = strtok(NULL, delim);
const char * field4 = strtok(NULL, delim);
if(field4 != NULL)
{
const float value_mbar = strtof(field4, NULL);
const float value_pascal = value_mbar * 100.0f;
const int snprintf_result = snprintf(outline, outlength, "$POV,Q,%f", value_pascal);
const uint8_t outline_checksum = nmea_checksum(outline);
fprintf(stdout, "%s*%02x\n", outline, outline_checksum);
fflush(stdout);
}
return ret;
}
int rpch_out_read(rdpRpch* rpch, uint8* data, int length)
{
int status;
rdpTls* tls_out = rpch->tls_out;
rdpRpchHTTP* http_out = rpch->http_out;
uint8* pdu;
uint8 ptype;
uint16 frag_length;
LLOGLN(10, ("rpch_out_read:"));
#if 0
if (rpch->AwailableWindow < 0x00008FFF) /* Just a simple workaround */
{
LLOGLN(10, ("rpch_out_read: calling rpch_in_send_flow_control"));
rpch_in_send_flow_control(rpch); /* send FlowControlAck every time AW reaches the half */
}
LLOGLN(10, ("rpch_out_read: 1"));
if (http_out->remContentLength <= 0xFFFF) /* TODO make ChannelRecycling */
{
LLOGLN(10, ("rpch_out_read: calling rpch_out_read_http_header"));
if (rpch_out_read_http_header(rpch) < 0)
{
LLOGLN(0, ("rpch_out_read: rpch_out_read_http_header failed"));
return -1;
}
}
LLOGLN(10, ("rpch_out_read: 2"));
if (http_out->contentLength != 0x40000000)
{
LLOGLN(0, ("rpch_out_read: 'Bad Request'"));
return -1;
}
#endif
pdu = (uint8*) xmalloc(0xFFFF);
#if 0
status = force_read(tls_out, pdu, 1);
if (status != 0)
{
LLOGLN(0, ("rpch_out_read: error"));
return -1;
}
if (pdu[0] == 'H')
{
if (rpch_out_read_http_header(rpch) < 0)
{
LLOGLN(0, ("rpch_out_read: rpch_out_read_http_header failed"));
return -1;
> }
return 0;
}
/*
* Read a directory entry into caller supplied buffer
*/
struct directory *dir_read(direntry_t *entry, int *error)
{
int n;
*error = 0;
if((n=force_read(entry->Dir, (char *) (&entry->dir),
(mt_off_t) entry->entry * MDIR_SIZE,
MDIR_SIZE)) != MDIR_SIZE) {
if (n < 0) {
*error = -1;
}
return NULL;
}
return &entry->dir;
}
static void displayInfosector(Stream_t *Stream, union bootsector *boot)
{
InfoSector_t *infosec;
if(WORD(ext.fat32.infoSector) == MAX16)
return;
infosec = (InfoSector_t *) safe_malloc(WORD(secsiz));
force_read(Stream, (char *) infosec,
(mt_off_t) WORD(secsiz) * WORD(ext.fat32.infoSector),
WORD(secsiz));
printf("\nInfosector:\n");
printf("signature=0x%08x\n", _DWORD(infosec->signature1));
if(_DWORD(infosec->count) != MAX32)
printf("free clusters=%u\n", _DWORD(infosec->count));
if(_DWORD(infosec->pos) != MAX32)
printf("last allocated cluster=%u\n", _DWORD(infosec->pos));
}
static uint64_t test_exception(void)
{
struct exception_handler sync_elx;
struct exception_handler sync_el0;
unsigned long long *a = (void *)0xffffffff00000000ULL;
sync_elx.handler = &test_exception_handler;
sync_el0.handler = &test_exception_handler;
exception_handler_register(EXC_VID_CUR_SP_ELX_SYNC, &sync_elx);
exception_handler_register(EXC_VID_CUR_SP_EL0_SYNC, &sync_el0);
force_read(*a);
exception_handler_unregister(EXC_VID_CUR_SP_ELX_SYNC, &sync_elx);
exception_handler_unregister(EXC_VID_CUR_SP_EL0_SYNC, &sync_el0);
return 0;
}
static int scan(Fs_t *Fs, Stream_t *dev,
long cluster, unsigned int badClus,
char *buffer, int write) {
off_t start;
off_t ret;
off_t pos;
int bad=0;
if(Fs->fat_decode((Fs_t*)Fs, cluster))
/* cluster busy, or already marked */
return 0;
start = (cluster - 2) * Fs->cluster_size + Fs->clus_start;
pos = sectorsToBytes((Stream_t*)Fs, start);
if(write) {
ret = force_write(dev, buffer, pos, in_len);
if(ret < in_len )
bad = 1;
} else {
ret = force_read(dev, in_buf, pos, in_len);
if(ret < in_len )
bad = 1;
else if(buffer) {
int i;
for(i=0; i<in_len; i++)
if(in_buf[i] != buffer[i]) {
bad = 1;
break;
}
}
}
if(bad) {
printf("Bad cluster %ld found\n", cluster);
fatEncode((Fs_t*)Fs, cluster, badClus);
return 1;
}
return 0;
}
void
rmstar(struct wordent *cp)
{
struct wordent *we, *args;
struct wordent *tmp, *del;
#ifdef RMDEBUG
static Char STRrmdebug[] = {'r', 'm', 'd', 'e', 'b', 'u', 'g', '\0'};
Char *tag;
#endif /* RMDEBUG */
Char *charac;
char c;
int ask, doit, star = 0, silent = 0, opintr_disabled;
if (!adrof(STRrmstar))
return;
#ifdef RMDEBUG
tag = varval(STRrmdebug);
#endif /* RMDEBUG */
we = cp->next;
while (*we->word == ';' && we != cp)
we = we->next;
opintr_disabled = pintr_disabled;
pintr_disabled = 0;
while (we != cp) {
#ifdef RMDEBUG
if (*tag)
xprintf(CGETS(22, 7, "parsing command line\n"));
#endif /* RMDEBUG */
if (!Strcmp(we->word, STRrm)) {
args = we->next;
ask = (*args->word != '-');
while (*args->word == '-' && !silent) { /* check options */
for (charac = (args->word + 1); *charac && !silent; charac++)
silent = (*charac == 'i' || *charac == 'f');
args = args->next;
}
ask = (ask || (!ask && !silent));
if (ask) {
for (; !star && *args->word != ';'
&& args != cp; args = args->next)
if (!Strcmp(args->word, STRstar))
star = 1;
if (ask && star) {
xprintf("%s", CGETS(22, 8,
"Do you really want to delete all files? [n/y] "));
flush();
(void) force_read(SHIN, &c, 1);
/*
* Perhaps we should use the yesexpr from the
* actual locale
*/
doit = (strchr(CGETS(22, 14, "Yy"), c) != NULL);
while (c != '\n' && force_read(SHIN, &c, 1) == 1)
continue;
if (!doit) {
/* remove the command instead */
#ifdef RMDEBUG
if (*tag)
xprintf(CGETS(22, 9,
"skipping deletion of files!\n"));
#endif /* RMDEBUG */
for (tmp = we;
*tmp->word != '\n' &&
*tmp->word != ';' && tmp != cp;) {
tmp->prev->next = tmp->next;
tmp->next->prev = tmp->prev;
xfree(tmp->word);
del = tmp;
tmp = tmp->next;
xfree(del);
}
if (*tmp->word == ';') {
tmp->prev->next = tmp->next;
tmp->next->prev = tmp->prev;
xfree(tmp->word);
del = tmp;
tmp = tmp->next;
xfree(del);
}
we = tmp;
continue;
}
}
}
}
for (we = we->next;
*we->word != ';' && we != cp;
we = we->next)
continue;
if (*we->word == ';')
we = we->next;
}
#ifdef RMDEBUG
if (*tag) {
xprintf(CGETS(22, 10, "command line now is:\n"));
for (we = cp->next; we != cp; we = we->next)
xprintf("%S ", we->word);
}
#endif /* RMDEBUG */
pintr_disabled = opintr_disabled;
return;
}
void mlabel(int argc, char **argv, int type)
{
char *newLabel;
int verbose, clear, interactive, show;
direntry_t entry;
int result=0;
char longname[VBUFSIZE];
char shortname[45];
ClashHandling_t ch;
struct MainParam_t mp;
Stream_t *RootDir;
int c;
int mangled;
enum { SER_NONE, SER_RANDOM, SER_SET } set_serial = SER_NONE;
long serial = 0;
int need_write_boot = 0;
int have_boot = 0;
char *eptr;
union bootsector boot;
Stream_t *Fs=0;
int r;
struct label_blk_t *labelBlock;
int isRo=0;
int *isRop=NULL;
init_clash_handling(&ch);
ch.name_converter = label_name;
ch.ignore_entry = -2;
verbose = 0;
clear = 0;
show = 0;
if(helpFlag(argc, argv))
usage(0);
while ((c = getopt(argc, argv, "i:vcsnN:h")) != EOF) {
switch (c) {
case 'i':
set_cmd_line_image(optarg, 0);
break;
case 'v':
verbose = 1;
break;
case 'c':
clear = 1;
break;
case 's':
show = 1;
break;
case 'n':
set_serial = SER_RANDOM;
srandom((long)time (0));
serial=random();
break;
case 'N':
set_serial = SER_SET;
serial = strtol(optarg, &eptr, 16);
if(*eptr) {
fprintf(stderr,
"%s not a valid serial number\n",
optarg);
exit(1);
}
break;
case 'h':
usage(0);
default:
usage(1);
}
}
if (argc - optind != 1 || !argv[optind][0] || argv[optind][1] != ':')
usage(1);
init_mp(&mp);
newLabel = argv[optind]+2;
if(strlen(newLabel) > VBUFSIZE) {
fprintf(stderr, "Label too long\n");
FREE(&RootDir);
exit(1);
}
interactive = !show && !clear &&!newLabel[0] &&
(set_serial == SER_NONE);
if(!clear && !newLabel[0]) {
isRop = &isRo;
}
RootDir = open_root_dir(argv[optind][0], isRop ? 0 : O_RDWR, isRop);
if(isRo) {
show = 1;
interactive = 0;
}
if(!RootDir) {
fprintf(stderr, "%s: Cannot initialize drive\n", argv[0]);
exit(1);
}
initializeDirentry(&entry, RootDir);
r=vfat_lookup(&entry, 0, 0, ACCEPT_LABEL | MATCH_ANY,
shortname, longname);
if (r == -2) {
FREE(&RootDir);
exit(1);
}
if(show || interactive){
if(isNotFound(&entry))
printf(" Volume has no label\n");
else if (*longname)
printf(" Volume label is %s (abbr=%s)\n",
longname, shortname);
else
printf(" Volume label is %s\n", shortname);
}
/* ask for new label */
if(interactive){
newLabel = longname;
fprintf(stderr,"Enter the new volume label : ");
if(fgets(newLabel, VBUFSIZE, stdin) == NULL) {
newLabel[0] = '\0';
fprintf(stderr, "\n");
}
if(newLabel[0])
newLabel[strlen(newLabel)-1] = '\0';
}
if((!show || newLabel[0]) && !isNotFound(&entry)){
/* if we have a label, wipe it out before putting new one */
if(interactive && newLabel[0] == '\0')
if(ask_confirmation("Delete volume label (y/n): ")){
FREE(&RootDir);
exit(0);
}
entry.dir.attr = 0; /* for old mlabel */
wipeEntry(&entry);
}
if (newLabel[0] != '\0') {
ch.ignore_entry = 1;
result = mwrite_one(RootDir,newLabel,0,labelit,NULL,&ch) ?
0 : 1;
}
have_boot = 0;
if( (!show || newLabel[0]) || set_serial != SER_NONE) {
Fs = GetFs(RootDir);
have_boot = (force_read(Fs,boot.characters,0,sizeof(boot)) ==
sizeof(boot));
}
if(WORD_S(fatlen)) {
labelBlock = &boot.boot.ext.old.labelBlock;
} else {
labelBlock = &boot.boot.ext.fat32.labelBlock;
}
if(!show || newLabel[0]){
dos_name_t dosname;
const char *shrtLabel;
doscp_t *cp;
if(!newLabel[0])
shrtLabel = "NO NAME ";
else
shrtLabel = newLabel;
cp = GET_DOSCONVERT(Fs);
label_name(cp, shrtLabel, verbose, &mangled, &dosname);
if(have_boot && boot.boot.descr >= 0xf0 &&
labelBlock->dos4 == 0x29) {
strncpy(labelBlock->label, dosname.base, 11);
need_write_boot = 1;
}
}
if((set_serial != SER_NONE) & have_boot) {
if(have_boot && boot.boot.descr >= 0xf0 &&
labelBlock->dos4 == 0x29) {
set_dword(labelBlock->serial, serial);
need_write_boot = 1;
}
}
if(need_write_boot) {
force_write(Fs, (char *)&boot, 0, sizeof(boot));
}
FREE(&RootDir);
exit(result);
}
/*
* Handle the multitudinous $ expansion forms.
* Ugh.
*/
static void
Dgetdol(void)
{
Char *np;
struct varent *vp = NULL;
struct Strbuf *name = Strbuf_alloc();
eChar c, sc;
int subscr = 0, lwb = 1, upb = 0;
int dimen = 0, bitset = 0, length = 0;
static Char *dolbang = NULL;
cleanup_push(name, Strbuf_free);
dolmod.len = dolmcnt = dol_flag_a = 0;
c = sc = DgetC(0);
if (c == DEOF) {
stderror(ERR_SYNTAX);
return;
}
if (c == '{')
c = DgetC(0); /* sc is { to take } later */
if ((c & TRIM) == '#')
dimen++, c = DgetC(0); /* $# takes dimension */
else if (c == '?')
bitset++, c = DgetC(0); /* $? tests existence */
else if (c == '%')
length++, c = DgetC(0); /* $% returns length in chars */
switch (c) {
case '!':
if (dimen || bitset || length)
stderror(ERR_SYNTAX);
if (backpid != 0) {
xfree(dolbang);
setDolp(dolbang = putn((tcsh_number_t)backpid));
}
cleanup_until(name);
goto eatbrac;
case '$':
if (dimen || bitset || length)
stderror(ERR_SYNTAX);
setDolp(doldol);
cleanup_until(name);
goto eatbrac;
case '<'|QUOTE: {
static struct Strbuf wbuf; /* = Strbuf_INIT; */
if (bitset)
stderror(ERR_NOTALLOWED, "$?<");
if (dimen)
stderror(ERR_NOTALLOWED, "$#<");
if (length)
stderror(ERR_NOTALLOWED, "$%<");
wbuf.len = 0;
{
char cbuf[MB_LEN_MAX];
size_t cbp = 0;
int old_pintr_disabled;
for (;;) {
int len;
ssize_t res;
Char wc;
pintr_push_enable(&old_pintr_disabled);
res = force_read(OLDSTD, cbuf + cbp, 1);
cleanup_until(&old_pintr_disabled);
if (res != 1)
break;
cbp++;
len = normal_mbtowc(&wc, cbuf, cbp);
if (len == -1) {
reset_mbtowc();
if (cbp < MB_LEN_MAX)
continue; /* Maybe a partial character */
wc = (unsigned char)*cbuf | INVALID_BYTE;
}
if (len <= 0)
len = 1;
if (cbp != (size_t)len)
memmove(cbuf, cbuf + len, cbp - len);
cbp -= len;
if (wc == '\n')
break;
Strbuf_append1(&wbuf, wc);
}
while (cbp != 0) {
int len;
Char wc;
len = normal_mbtowc(&wc, cbuf, cbp);
if (len == -1) {
reset_mbtowc();
wc = (unsigned char)*cbuf | INVALID_BYTE;
}
if (len <= 0)
len = 1;
if (cbp != (size_t)len)
memmove(cbuf, cbuf + len, cbp - len);
cbp -= len;
if (wc == '\n')
break;
Strbuf_append1(&wbuf, wc);
}
Strbuf_terminate(&wbuf);
}
fixDolMod();
setDolp(wbuf.s); /* Kept allocated until next $< expansion */
cleanup_until(name);
goto eatbrac;
}
case '*':
Strbuf_append(name, STRargv);
Strbuf_terminate(name);
vp = adrof(STRargv);
subscr = -1; /* Prevent eating [...] */
break;
case DEOF:
case '\n':
np = dimen ? STRargv : (bitset ? STRstatus : NULL);
if (np) {
bitset = 0;
Strbuf_append(name, np);
Strbuf_terminate(name);
vp = adrof(np);
subscr = -1; /* Prevent eating [...] */
unDredc(c);
break;
}
else
stderror(ERR_SYNTAX);
/*NOTREACHED*/
default:
if (Isdigit(c)) {
if (dimen)
stderror(ERR_NOTALLOWED, "$#<num>");
subscr = 0;
do {
subscr = subscr * 10 + c - '0';
c = DgetC(0);
} while (c != DEOF && Isdigit(c));
unDredc(c);
if (subscr < 0)
stderror(ERR_RANGE);
if (subscr == 0) {
if (bitset) {
dolp = dolzero ? STR1 : STR0;
cleanup_until(name);
goto eatbrac;
}
if (ffile == 0)
stderror(ERR_DOLZERO);
if (length) {
length = Strlen(ffile);
addla(putn((tcsh_number_t)length));
}
else {
fixDolMod();
setDolp(ffile);
}
cleanup_until(name);
goto eatbrac;
}
#if 0
if (bitset)
stderror(ERR_NOTALLOWED, "$?<num>");
if (length)
stderror(ERR_NOTALLOWED, "$%<num>");
#endif
vp = adrof(STRargv);
if (vp == 0) {
vp = &nulargv;
cleanup_until(name);
goto eatmod;
}
break;
}
if (c == DEOF || !alnum(c)) {
np = dimen ? STRargv : (bitset ? STRstatus : NULL);
if (np) {
bitset = 0;
Strbuf_append(name, np);
Strbuf_terminate(name);
vp = adrof(np);
subscr = -1; /* Prevent eating [...] */
unDredc(c);
break;
}
else
stderror(ERR_VARALNUM);
}
for (;;) {
Strbuf_append1(name, (Char) c);
c = DgetC(0);
if (c == DEOF || !alnum(c))
break;
}
Strbuf_terminate(name);
unDredc(c);
vp = adrof(name->s);
}
if (bitset) {
dolp = (vp || getenv(short2str(name->s))) ? STR1 : STR0;
cleanup_until(name);
goto eatbrac;
}
if (vp == NULL || vp->vec == NULL) {
np = str2short(getenv(short2str(name->s)));
if (np) {
static Char *env_val; /* = NULL; */
cleanup_until(name);
fixDolMod();
if (length) {
addla(putn((tcsh_number_t)Strlen(np)));
} else {
xfree(env_val);
env_val = Strsave(np);
setDolp(env_val);
}
goto eatbrac;
}
udvar(name->s);
/* NOTREACHED */
}
cleanup_until(name);
c = DgetC(0);
upb = blklen(vp->vec);
if (dimen == 0 && subscr == 0 && c == '[') {
name = Strbuf_alloc();
cleanup_push(name, Strbuf_free);
np = name->s;
for (;;) {
c = DgetC(DODOL); /* Allow $ expand within [ ] */
if (c == ']')
break;
if (c == '\n' || c == DEOF)
stderror(ERR_INCBR);
Strbuf_append1(name, (Char) c);
}
Strbuf_terminate(name);
np = name->s;
if (dolp || dolcnt) /* $ exp must end before ] */
stderror(ERR_EXPORD);
if (!*np)
stderror(ERR_SYNTAX);
if (Isdigit(*np)) {
int i;
for (i = 0; Isdigit(*np); i = i * 10 + *np++ - '0')
continue;
if (i < 0 || (i > upb && !any("-*", *np))) {
cleanup_until(name);
dolerror(vp->v_name);
return;
}
lwb = i;
if (!*np)
upb = lwb, np = STRstar;
}
if (*np == '*')
np++;
else if (*np != '-')
stderror(ERR_MISSING, '-');
else {
int i = upb;
np++;
if (Isdigit(*np)) {
i = 0;
while (Isdigit(*np))
i = i * 10 + *np++ - '0';
if (i < 0 || i > upb) {
cleanup_until(name);
dolerror(vp->v_name);
return;
}
}
if (i < lwb)
upb = lwb - 1;
else
upb = i;
}
if (lwb == 0) {
if (upb != 0) {
cleanup_until(name);
dolerror(vp->v_name);
return;
}
upb = -1;
}
if (*np)
stderror(ERR_SYNTAX);
cleanup_until(name);
}
else {
if (subscr > 0) {
if (subscr > upb)
lwb = 1, upb = 0;
else
lwb = upb = subscr;
}
unDredc(c);
}
if (dimen) {
/* this is a kludge. It prevents Dgetdol() from */
/* pushing erroneous ${#<error> values into the labuf. */
if (sc == '{') {
c = Dredc();
if (c != '}')
stderror(ERR_MISSING, '}');
unDredc(c);
}
addla(putn((tcsh_number_t)(upb - lwb + 1)));
}
else if (length) {
int i;
for (i = lwb - 1, length = 0; i < upb; i++)
length += Strlen(vp->vec[i]);
#ifdef notdef
/* We don't want that, since we can always compute it by adding $#xxx */
length += i - 1; /* Add the number of spaces in */
#endif
addla(putn((tcsh_number_t)length));
}
else {
eatmod:
fixDolMod();
dolnxt = &vp->vec[lwb - 1];
dolcnt = upb - lwb + 1;
}
eatbrac:
if (sc == '{') {
c = Dredc();
if (c != '}')
stderror(ERR_MISSING, '}');
}
}
LLOGLN(0, ("rpch_out_read: error"));
return -1;
}
if (pdu[0] == 'H')
{
if (rpch_out_read_http_header(rpch) < 0)
{
LLOGLN(0, ("rpch_out_read: rpch_out_read_http_header failed"));
return -1;
> }
return 0;
}
#endif
//status = tls_read(tls_out, pdu, 10);
status = force_read(tls_out, pdu, 10);
if (status <= 9) /* read first 10 bytes to get the frag_length value */
{
LLOGLN(0, ("rpch_out_read: tls_read failed, not enough"));
xfree(pdu);
return -1;
}
ptype = *(pdu + 2);
frag_length = *((uint16*)(pdu + 8));
LLOGLN(10, ("rpch_out_read: frag_length %d", frag_length));
//status = tls_read(tls_out, pdu + 10, frag_length - 10);
status = force_read(tls_out, pdu + 10, frag_length - 10);
if (status < 0)
{
int fatlabel_set_label(const char* device_name, const char* new_label)
{
if (strlen(new_label) > VBUFSIZE)
return -1;
/*
* 1. Init clash handling
*/
struct ClashHandling_t ch;
init_clash_handling(&ch);
ch.name_converter = label_name;
ch.ignore_entry = -2;
/*
* 2. Open root dir
*/
struct Stream_t* RootDir = fs_init(device_name, O_RDWR);
if (RootDir)
RootDir = OpenRoot(RootDir);
if (!RootDir)
{
fprintf(stderr, "Opening root dir failed.\n");
return -2;
}
/*
* 3. Init dir entry
*/
struct direntry_t entry;
initializeDirentry(&entry, RootDir);
/*
* 4. Lookup vfat
*/
char longname[VBUFSIZE];
char shortname[45];
if (vfat_lookup(&entry, 0, 0, ACCEPT_LABEL | MATCH_ANY, shortname, longname) == -2)
{
fprintf(stderr, "Looking up vfat failed.\n");
free_stream(&RootDir);
return -3;
}
/*
* 5. Wipe existing entry.
*/
if (!isNotFound(&entry))
{
/* if we have a label, wipe it out before putting new one */
entry.dir.attr = 0; /* for old mlabel */
wipeEntry(&entry);
}
/*
* 6. Write new entry
*/
ch.ignore_entry = 1;
/* don't try to write the label if it's empty */
int result = strlen(new_label) ? mwrite_one(RootDir, new_label, labelit, &ch) : 0;
/*
* 7. Load FAT boot record
*/
union bootsector boot;
struct Stream_t* Fs = GetFs(RootDir);
int have_boot = force_read(Fs, boot.characters, 0, sizeof(boot)) == sizeof(boot);
struct label_blk_t* labelBlock = WORD_S(fatlen) ? &boot.boot.ext.old.labelBlock : &boot.boot.ext.fat32.labelBlock;
/*
* 8. Get "dosconvert" struct
*/
struct dos_name_t dosname;
struct doscp_t* cp = GET_DOSCONVERT(Fs);
/*
* 9. Convert label
*/
int mangled = 0;
label_name(cp, new_label, &mangled, &dosname);
/*
* 10. Overwrite FAT boot record
*/
if (have_boot && boot.boot.descr >= 0xf0 && labelBlock->dos4 == 0x29)
{
strncpy(labelBlock->label, dosname.base, 11);
force_write(Fs, (char *)&boot, 0, sizeof(boot));
}
free_stream(&RootDir);
fs_close(Fs);
return result;
}