| /* ----------------------------------------------------------------------- * |
| * |
| * Copyright 2003-2009 H. Peter Anvin - All Rights Reserved |
| * Copyright 2009-2010 Intel Corporation; author: H. Peter Anvin |
| * Copyright 2010 Shao Miller |
| * Copyright 2010-2012 Michal Soltys |
| * |
| * Permission is hereby granted, free of charge, to any person |
| * obtaining a copy of this software and associated documentation |
| * files (the "Software"), to deal in the Software without |
| * restriction, including without limitation the rights to use, |
| * copy, modify, merge, publish, distribute, sublicense, and/or |
| * sell copies of the Software, and to permit persons to whom |
| * the Software is furnished to do so, subject to the following |
| * conditions: |
| * |
| * The above copyright notice and this permission notice shall |
| * be included in all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES |
| * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
| * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT |
| * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, |
| * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
| * OTHER DEALINGS IN THE SOFTWARE. |
| * |
| * ----------------------------------------------------------------------- */ |
| |
| /* |
| * partiter.c |
| * |
| * Provides disk / partition iteration. |
| */ |
| |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <string.h> |
| #include <stdarg.h> |
| #include <zlib.h> |
| #include <syslinux/disk.h> |
| #include "partiter.h" |
| #include "utility.h" |
| |
| #define ost_is_ext(type) ((type) == 0x05 || (type) == 0x0F || (type) == 0x85) |
| #define ost_is_nondata(type) (ost_is_ext(type) || (type) == 0x00) |
| #define sane(s,l) ((s)+(l) > (s)) |
| |
| /* virtual forwards */ |
| |
| static void pi_dtor_(struct part_iter *); |
| static int pi_next_(struct part_iter *); |
| static int pi_dos_next(struct part_iter *); |
| static int pi_gpt_next(struct part_iter *); |
| |
| /* vtab and types */ |
| |
| static struct itertype types[] = { |
| [0] = { |
| .dtor = &pi_dtor_, |
| .next = &pi_dos_next, |
| }, [1] = { |
| .dtor = &pi_dtor_, |
| .next = &pi_gpt_next, |
| }, [2] = { |
| .dtor = &pi_dtor_, |
| .next = &pi_next_, |
| }}; |
| |
| const struct itertype * const typedos = types; |
| const struct itertype * const typegpt = types+1; |
| const struct itertype * const typeraw = types+2; |
| |
| /* pi_dtor_() - common/raw iterator cleanup */ |
| static void pi_dtor_(struct part_iter *iter) |
| { |
| /* syslinux's free is null resilient */ |
| free(iter->data); |
| } |
| |
| /* pi_ctor() - common/raw iterator initialization */ |
| static int pi_ctor(struct part_iter *iter, |
| const struct disk_info *di, int flags |
| ) |
| { |
| memcpy(&iter->di, di, sizeof *di); |
| iter->flags = flags; |
| iter->index0 = -1; |
| iter->length = di->lbacnt; |
| |
| iter->type = typeraw; |
| return 0; |
| } |
| |
| /* pi_dos_ctor() - MBR/EBR iterator specific initialization */ |
| static int pi_dos_ctor(struct part_iter *iter, |
| const struct disk_info *di, int flags, |
| const struct disk_dos_mbr *mbr |
| ) |
| { |
| if (pi_ctor(iter, di, flags)) |
| return -1; |
| |
| if (!(iter->data = malloc(sizeof *mbr))) { |
| critm(); |
| goto bail; |
| } |
| |
| memcpy(iter->data, mbr, sizeof *mbr); |
| |
| iter->dos.bebr_index0 = -1; |
| iter->dos.disk_sig = mbr->disk_sig; |
| |
| iter->type = typedos; |
| return 0; |
| bail: |
| pi_dtor_(iter); |
| return -1; |
| } |
| |
| /* pi_gpt_ctor() - GPT iterator specific initialization */ |
| static int pi_gpt_ctor(struct part_iter *iter, |
| const struct disk_info *di, int flags, |
| const struct disk_gpt_header *gpth, const struct disk_gpt_part_entry *gptl |
| ) |
| { |
| uint64_t siz; |
| |
| if (pi_ctor(iter, di, flags)) |
| return -1; |
| |
| siz = (uint64_t)gpth->part_count * gpth->part_size; |
| |
| if (!(iter->data = malloc((size_t)siz))) { |
| critm(); |
| goto bail; |
| } |
| |
| memcpy(iter->data, gptl, (size_t)siz); |
| |
| iter->gpt.pe_count = (int)gpth->part_count; |
| iter->gpt.pe_size = (int)gpth->part_size; |
| iter->gpt.ufirst = gpth->lba_first_usable; |
| iter->gpt.ulast = gpth->lba_last_usable; |
| |
| memcpy(&iter->gpt.disk_guid, &gpth->disk_guid, sizeof gpth->disk_guid); |
| memcpy(&iter->gpt.part_guid, &gpth->disk_guid, sizeof gpth->disk_guid); |
| |
| iter->type = typegpt; |
| return 0; |
| bail: |
| pi_dtor_(iter); |
| return -1; |
| } |
| |
| /* Logical partition must be sane, meaning: |
| * - must be data or empty |
| * - must have non-0 start and length |
| * - values must not wrap around 32bit |
| * - must be inside current EBR frame |
| */ |
| |
| static int notsane_logical(const struct part_iter *iter) |
| { |
| const struct disk_dos_part_entry *dp; |
| uint32_t end_log; |
| |
| dp = ((struct disk_dos_mbr *)iter->data)->table; |
| |
| if (!dp[0].ostype) |
| return 0; |
| |
| if (ost_is_ext(dp[0].ostype)) { |
| error("The 1st EBR entry must be data or empty."); |
| return -1; |
| } |
| |
| if (!(iter->flags & PIF_STRICT)) |
| return 0; |
| |
| end_log = dp[0].start_lba + dp[0].length; |
| |
| if (!dp[0].start_lba || |
| !dp[0].length || |
| !sane(dp[0].start_lba, dp[0].length) || |
| end_log > iter->dos.nebr_siz) { |
| |
| error("Logical partition (in EBR) with invalid offset and/or length."); |
| return -1; |
| } |
| |
| return 0; |
| } |
| |
| /* Extended partition must be sane, meaning: |
| * - must be extended or empty |
| * - must have non-0 start and length |
| * - values must not wrap around 32bit |
| * - must be inside base EBR frame |
| */ |
| |
| static int notsane_extended(const struct part_iter *iter) |
| { |
| const struct disk_dos_part_entry *dp; |
| uint32_t end_ebr; |
| |
| dp = ((struct disk_dos_mbr *)iter->data)->table; |
| |
| if (!dp[1].ostype) |
| return 0; |
| |
| if (!ost_is_nondata(dp[1].ostype)) { |
| error("The 2nd EBR entry must be extended or empty."); |
| return -1; |
| } |
| |
| if (!(iter->flags & PIF_STRICT)) |
| return 0; |
| |
| end_ebr = dp[1].start_lba + dp[1].length; |
| |
| if (!dp[1].start_lba || |
| !dp[1].length || |
| !sane(dp[1].start_lba, dp[1].length) || |
| end_ebr > iter->dos.bebr_siz) { |
| |
| error("Extended partition (EBR) with invalid offset and/or length."); |
| return -1; |
| } |
| |
| return 0; |
| } |
| |
| /* Primary partition must be sane, meaning: |
| * - must have non-0 start and length |
| * - values must not wrap around 32bit |
| */ |
| |
| static int notsane_primary(const struct part_iter *iter) |
| { |
| const struct disk_dos_part_entry *dp; |
| dp = ((struct disk_dos_mbr *)iter->data)->table + iter->index0; |
| |
| if (!dp->ostype) |
| return 0; |
| |
| if (!(iter->flags & PIF_STRICT)) |
| return 0; |
| |
| if (!dp->start_lba || |
| !dp->length || |
| !sane(dp->start_lba, dp->length) || |
| ((iter->flags & PIF_STRICTER) && (dp->start_lba + dp->length > iter->di.lbacnt))) { |
| error("Primary partition (in MBR) with invalid offset and/or length."); |
| return -1; |
| } |
| |
| return 0; |
| } |
| |
| static int notsane_gpt(const struct part_iter *iter) |
| { |
| const struct disk_gpt_part_entry *gp; |
| gp = (const struct disk_gpt_part_entry *) |
| (iter->data + iter->index0 * iter->gpt.pe_size); |
| |
| if (guid_is0(&gp->type)) |
| return 0; |
| |
| if (!(iter->flags & PIF_STRICT)) |
| return 0; |
| |
| if (gp->lba_first < iter->gpt.ufirst || |
| gp->lba_last > iter->gpt.ulast) { |
| error("LBA sectors of GPT partition are beyond the range allowed in GPT header."); |
| return -1; |
| } |
| |
| return 0; |
| } |
| |
| static int dos_next_mbr(struct part_iter *iter, uint32_t *lba, |
| struct disk_dos_part_entry **_dp) |
| { |
| struct disk_dos_part_entry *dp; |
| |
| while (++iter->index0 < 4) { |
| dp = ((struct disk_dos_mbr *)iter->data)->table + iter->index0; |
| |
| if (notsane_primary(iter)) { |
| iter->status = PI_INSANE; |
| return -1; |
| } |
| |
| if (ost_is_ext(dp->ostype)) { |
| if (iter->dos.bebr_index0 >= 0) { |
| error("More than 1 extended partition."); |
| iter->status = PI_INSANE; |
| return -1; |
| } |
| /* record base EBR index */ |
| iter->dos.bebr_index0 = iter->index0; |
| } |
| if (!ost_is_nondata(dp->ostype) || (iter->flags & PIF_STEPALL)) { |
| *lba = dp->start_lba; |
| *_dp = dp; |
| break; |
| } |
| } |
| |
| return 0; |
| } |
| |
| static int prep_base_ebr(struct part_iter *iter) |
| { |
| struct disk_dos_part_entry *dp; |
| |
| if (iter->dos.bebr_index0 < 0) /* if we don't have base extended partition at all */ |
| return -1; |
| else if (!iter->dos.bebr_lba) { /* if not initialized yet */ |
| dp = ((struct disk_dos_mbr *)iter->data)->table + iter->dos.bebr_index0; |
| |
| iter->dos.bebr_lba = dp->start_lba; |
| iter->dos.bebr_siz = dp->length; |
| |
| iter->dos.nebr_lba = dp->start_lba; |
| iter->dos.nebr_siz = dp->length; |
| |
| iter->index0--; |
| } |
| return 0; |
| } |
| |
| static int dos_next_ebr(struct part_iter *iter, uint32_t *lba, |
| struct disk_dos_part_entry **_dp) |
| { |
| struct disk_dos_part_entry *dp; |
| |
| if (prep_base_ebr(iter) < 0) { |
| iter->status = PI_DONE; |
| return -1; |
| } |
| |
| while (++iter->index0 < 1024 && iter->dos.nebr_lba) { |
| free(iter->data); |
| if (!(iter->data = |
| disk_read_sectors(&iter->di, iter->dos.nebr_lba, 1))) { |
| error("Couldn't load EBR."); |
| iter->status = PI_ERRLOAD; |
| return -1; |
| } |
| |
| /* check sanity of loaded data */ |
| if (notsane_logical(iter) || notsane_extended(iter)) { |
| iter->status = PI_INSANE; |
| return -1; |
| } |
| |
| dp = ((struct disk_dos_mbr *)iter->data)->table; |
| |
| iter->dos.cebr_lba = iter->dos.nebr_lba; |
| iter->dos.cebr_siz = iter->dos.nebr_siz; |
| |
| /* setup next frame values */ |
| if (dp[1].ostype) { |
| iter->dos.nebr_lba = iter->dos.bebr_lba + dp[1].start_lba; |
| iter->dos.nebr_siz = dp[1].length; |
| } else { |
| iter->dos.nebr_lba = 0; |
| iter->dos.nebr_siz = 0; |
| } |
| |
| if (!dp[0].ostype) |
| iter->dos.logskipcnt++; |
| |
| if (dp[0].ostype || (iter->flags & PIF_STEPALL)) { |
| *lba = dp[0].start_lba ? iter->dos.cebr_lba + dp[0].start_lba : 0; |
| *_dp = dp; |
| return 0; |
| } |
| /* |
| * This way it's possible to continue, if some crazy soft left a "hole" |
| * - EBR with a valid extended partition without a logical one. In |
| * such case, linux will not reserve a number for such hole - so we |
| * don't increase index0. If PIF_STEPALL flag is set, we will never |
| * reach this place. |
| */ |
| } |
| iter->status = PI_DONE; |
| return -1; |
| } |
| |
| static void gpt_conv_label(struct part_iter *iter) |
| { |
| const struct disk_gpt_part_entry *gp; |
| const int16_t *orig_lab; |
| |
| gp = (const struct disk_gpt_part_entry *) |
| (iter->data + iter->index0 * iter->gpt.pe_size); |
| orig_lab = (const int16_t *)gp->name; |
| |
| /* caveat: this is very crude conversion */ |
| for (int i = 0; i < PI_GPTLABSIZE/2; i++) { |
| iter->gpt.part_label[i] = (char)orig_lab[i]; |
| } |
| iter->gpt.part_label[PI_GPTLABSIZE/2] = 0; |
| } |
| |
| static inline int valid_crc(uint32_t crc, const uint8_t *buf, unsigned int siz) |
| { |
| return crc == crc32(crc32(0, NULL, 0), buf, siz); |
| } |
| |
| static int valid_crc_hdr(void *buf) |
| { |
| struct disk_gpt_header *gh = buf; |
| uint32_t crc = gh->chksum; |
| int valid; |
| |
| gh->chksum = 0; |
| valid = crc == crc32(crc32(0, NULL, 0), buf, gh->hdr_size); |
| gh->chksum = crc; |
| return valid; |
| } |
| |
| static int pi_next_(struct part_iter *iter) |
| { |
| iter->status = PI_DONE; |
| return iter->status; |
| } |
| |
| static int pi_dos_next(struct part_iter *iter) |
| { |
| uint32_t abs_lba = 0; |
| struct disk_dos_part_entry *dos_part = NULL; |
| |
| if (iter->status) |
| return iter->status; |
| |
| /* look for primary partitions */ |
| if (iter->index0 < 4 && |
| dos_next_mbr(iter, &abs_lba, &dos_part) < 0) |
| return iter->status; |
| |
| /* look for logical partitions */ |
| if (iter->index0 >= 4 && |
| dos_next_ebr(iter, &abs_lba, &dos_part) < 0) |
| return iter->status; |
| |
| /* |
| * note special index handling: |
| * in case PIF_STEPALL is set - this makes the index consistent with |
| * non-PIF_STEPALL iterators |
| */ |
| |
| if (!dos_part->ostype) |
| iter->index = -1; |
| else |
| iter->index = iter->index0 + 1 - iter->dos.logskipcnt; |
| iter->abs_lba = abs_lba; |
| iter->length = dos_part->length; |
| iter->record = (char *)dos_part; |
| |
| #ifdef DEBUG |
| disk_dos_part_dump(dos_part); |
| #endif |
| |
| return iter->status; |
| } |
| |
| static int pi_gpt_next(struct part_iter *iter) |
| { |
| const struct disk_gpt_part_entry *gpt_part = NULL; |
| |
| if (iter->status) |
| return iter->status; |
| |
| while (++iter->index0 < iter->gpt.pe_count) { |
| gpt_part = (const struct disk_gpt_part_entry *) |
| (iter->data + iter->index0 * iter->gpt.pe_size); |
| |
| if (notsane_gpt(iter)) { |
| iter->status = PI_INSANE; |
| return iter->status; |
| } |
| |
| if (!guid_is0(&gpt_part->type) || (iter->flags & PIF_STEPALL)) |
| break; |
| } |
| /* no more partitions ? */ |
| if (iter->index0 == iter->gpt.pe_count) { |
| iter->status = PI_DONE; |
| return iter->status; |
| } |
| /* gpt_part is guaranteed to be valid here */ |
| iter->index = iter->index0 + 1; |
| iter->abs_lba = gpt_part->lba_first; |
| iter->length = gpt_part->lba_last - gpt_part->lba_first + 1; |
| iter->record = (char *)gpt_part; |
| memcpy(&iter->gpt.part_guid, &gpt_part->uid, sizeof(struct guid)); |
| gpt_conv_label(iter); |
| |
| #ifdef DEBUG |
| disk_gpt_part_dump(gpt_part); |
| #endif |
| |
| return iter->status; |
| } |
| |
| static struct part_iter *pi_alloc(void) |
| { |
| struct part_iter *iter; |
| if (!(iter = malloc(sizeof *iter))) |
| critm(); |
| else |
| memset(iter, 0, sizeof *iter); |
| return iter; |
| } |
| |
| /* pi_del() - delete iterator */ |
| void pi_del(struct part_iter **_iter) |
| { |
| if(!_iter || !*_iter) |
| return; |
| pi_dtor(*_iter); |
| free(*_iter); |
| *_iter = NULL; |
| } |
| |
| static void try_gpt_we(const char *str, int sec) |
| { |
| if (sec) |
| error(str); |
| else |
| warn(str); |
| } |
| |
| static struct disk_gpt_header *try_gpt_hdr(const struct disk_info *di, int sec) |
| { |
| const char *desc = sec ? "backup" : "primary"; |
| uint64_t gpt_cur = sec ? di->lbacnt - 1 : 1; |
| struct disk_gpt_header *gpth; |
| char errbuf[64]; |
| |
| gpth = disk_read_sectors(di, gpt_cur, 1); |
| if (!gpth) { |
| sprintf(errbuf, "Unable to read %s GPT header.", desc); |
| try_gpt_we(errbuf, sec); |
| return NULL; |
| } |
| if(!valid_crc_hdr(gpth)) { |
| sprintf(errbuf, "Invalid checksum of %s GPT header.", desc); |
| try_gpt_we(errbuf, sec); |
| free(gpth); |
| return NULL; |
| } |
| return gpth; |
| } |
| |
| static struct disk_gpt_part_entry *try_gpt_list(const struct disk_info *di, const struct disk_gpt_header *gpth, int alt) |
| { |
| int pri = gpth->lba_cur < gpth->lba_alt; |
| const char *desc = alt ? "alternative" : "main"; |
| struct disk_gpt_part_entry *gptl; |
| char errbuf[64]; |
| uint64_t gpt_lsiz; /* size of GPT partition list in bytes */ |
| uint64_t gpt_lcnt; /* size of GPT partition in sectors */ |
| uint64_t gpt_loff; /* offset to GPT partition list in sectors */ |
| |
| gpt_lsiz = (uint64_t)gpth->part_size * gpth->part_count; |
| gpt_lcnt = (gpt_lsiz + di->bps - 1) / di->bps; |
| if (!alt) { |
| /* prefer header value for partition table if not asking for alternative */ |
| gpt_loff = gpth->lba_table; |
| } else { |
| /* try to read alternative, we have to calculate its position */ |
| if (!pri) |
| gpt_loff = gpth->lba_alt + 1; |
| else |
| gpt_loff = gpth->lba_alt - gpt_lcnt; |
| } |
| |
| gptl = disk_read_sectors(di, gpt_loff, gpt_lcnt); |
| if (!gptl) { |
| sprintf(errbuf, "Unable to read %s GPT partition list.", desc); |
| try_gpt_we(errbuf, alt); |
| return NULL; |
| } |
| if (!valid_crc(gpth->table_chksum, (const uint8_t *)gptl, gpt_lsiz)) { |
| sprintf(errbuf, "Invalid checksum of %s GPT partition list.", desc); |
| try_gpt_we(errbuf, alt); |
| free(gptl); |
| return NULL; |
| } |
| return gptl; |
| } |
| |
| static int notsane_gpt_hdr(const struct disk_info *di, const struct disk_gpt_header *gpth, int flags) |
| { |
| uint64_t gpt_loff; /* offset to GPT partition list in sectors */ |
| uint64_t gpt_lsiz; /* size of GPT partition list in bytes */ |
| uint64_t gpt_lcnt; /* size of GPT partition in sectors */ |
| uint64_t gpt_sec; /* secondary gpt header */ |
| |
| if (!(flags & PIF_STRICT)) |
| return 0; |
| |
| if (gpth->lba_alt < gpth->lba_cur) |
| gpt_sec = gpth->lba_cur; |
| else |
| gpt_sec = gpth->lba_alt; |
| gpt_loff = gpth->lba_table; |
| gpt_lsiz = (uint64_t)gpth->part_size * gpth->part_count; |
| gpt_lcnt = (gpt_lsiz + di->bps - 1) / di->bps; |
| |
| /* |
| * disk_read_sectors allows reading of max 255 sectors, so we use |
| * it as a sanity check base. EFI doesn't specify max (AFAIK). |
| */ |
| if (gpt_loff < 2 || !gpt_lsiz || gpt_lcnt > 255u || |
| gpth->lba_first_usable > gpth->lba_last_usable || |
| !sane(gpt_loff, gpt_lcnt) || |
| (gpt_loff + gpt_lcnt > gpth->lba_first_usable && gpt_loff <= gpth->lba_last_usable) || |
| gpt_loff + gpt_lcnt > gpt_sec || |
| ((flags & PIF_STRICTER) && (gpt_sec >= di->lbacnt)) || |
| gpth->part_size < sizeof(struct disk_gpt_part_entry)) |
| return -1; |
| |
| return 0; |
| } |
| |
| /* pi_begin() - validate and and get proper iterator for a disk described by di */ |
| struct part_iter *pi_begin(const struct disk_info *di, int flags) |
| { |
| int isgpt = 0, ret = -1; |
| struct part_iter *iter; |
| struct disk_dos_mbr *mbr = NULL; |
| struct disk_gpt_header *gpth = NULL; |
| struct disk_gpt_part_entry *gptl = NULL; |
| |
| /* Preallocate iterator */ |
| if (!(iter = pi_alloc())) |
| goto out; |
| |
| /* Read MBR */ |
| if (!(mbr = disk_read_sectors(di, 0, 1))) { |
| error("Unable to read the first disk sector."); |
| goto out; |
| } |
| |
| /* Check for MBR magic */ |
| if (mbr->sig != disk_mbr_sig_magic) { |
| warn("No MBR magic, treating disk as raw."); |
| /* looks like RAW */ |
| ret = pi_ctor(iter, di, flags); |
| goto out; |
| } |
| |
| /* Check for GPT protective MBR */ |
| for (size_t i = 0; i < 4; i++) |
| isgpt |= (mbr->table[i].ostype == 0xEE); |
| isgpt = isgpt && !(flags & PIF_PREFMBR); |
| |
| /* Try to read GPT header */ |
| if (isgpt) { |
| gpth = try_gpt_hdr(di, 0); |
| if (!gpth) |
| /* |
| * this read might fail if bios reports different disk size (different vm/pc) |
| * not much we can do here to avoid it |
| */ |
| gpth = try_gpt_hdr(di, 1); |
| if (!gpth) |
| goto out; |
| } |
| |
| if (gpth && gpth->rev.uint32 == 0x00010000 && |
| !memcmp(gpth->sig, disk_gpt_sig_magic, sizeof gpth->sig)) { |
| /* looks like GPT v1.0 */ |
| #ifdef DEBUG |
| dprintf("Looks like a GPT v1.0 disk.\n"); |
| disk_gpt_header_dump(gpth); |
| #endif |
| if (notsane_gpt_hdr(di, gpth, flags)) { |
| error("GPT header values are corrupted."); |
| goto out; |
| } |
| |
| gptl = try_gpt_list(di, gpth, 0); |
| if (!gptl) |
| gptl = try_gpt_list(di, gpth, 1); |
| if (!gptl) |
| goto out; |
| |
| /* looks like GPT */ |
| ret = pi_gpt_ctor(iter, di, flags, gpth, gptl); |
| } else { |
| /* looks like MBR */ |
| ret = pi_dos_ctor(iter, di, flags, mbr); |
| } |
| out: |
| if (ret < 0) { |
| free(iter); |
| iter = NULL; |
| } |
| free(mbr); |
| free(gpth); |
| free(gptl); |
| |
| return iter; |
| } |
| |
| /* vim: set ts=8 sts=4 sw=4 noet: */ |