git.gag.com Git - debian/amanda/blob - ndmp-src/smc_parse.c

   1 /*
   2  * Copyright (c) 1998,1999,2000
   3  *      Traakan, Inc., Los Altos, CA
   4  *      All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice unmodified, this list of conditions, and the following
  11  *    disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 /*
  30  * Project:  NDMJOB
  31  * Ident:    $Id: $
  32  *
  33  * Description:
  34  *
  35  */
  36
  37
  38 #include "smc_priv.h"
  39
  40
  41 #define WITH(P,V,T)     { T * V = (T *) P;
  42 #define ENDWITH         }
  43
  44 int
  45 smc_parse_volume_tag (
  46   struct smc_raw_volume_tag *raw,
  47   struct smc_volume_tag *vtag)
  48 {
  49         int             i;
  50
  51         bzero (vtag, sizeof *vtag);
  52
  53         for (i = 31; i >= 0 && raw->volume_id[i] == ' '; i--)
  54                 continue;
  55
  56         for (; i >= 0; i--)
  57                 vtag->volume_id[i] = raw->volume_id[i];
  58
  59         vtag->volume_seq = SMC_GET2(raw->volume_seq);
  60
  61         return 0;
  62 }
  63
  64
  65
  66 int
  67 smc_parse_element_status_data (
  68   char *        raw,
  69   unsigned      raw_len,
  70   struct smc_element_descriptor elem_desc[],
  71   unsigned      max_elem_desc)
  72 {
  73         unsigned char *                 p = (unsigned char *)raw;
  74         unsigned char *                 raw_end = p + raw_len;
  75         unsigned int                    n_elem = 0;
  76
  77         bzero (elem_desc, sizeof elem_desc[0] * max_elem_desc);
  78
  79         WITH(p, esdh, struct smc_raw_element_status_data_header)
  80                 unsigned        byte_count = SMC_GET3(esdh->byte_count);
  81
  82                 if (raw_len > byte_count+8) {
  83                         /* probably an error, but press on */
  84                         raw_len = byte_count+8;
  85                 }
  86                 raw_end = p + raw_len;
  87         ENDWITH
  88
  89         p += 8;
  90
  91         while (p+8 < raw_end) {         /* +8 for sizeof *esph */
  92             WITH(p, esph, struct smc_raw_element_status_page_header)
  93                 unsigned        desc_size = SMC_GET2(esph->elem_desc_len);
  94                 unsigned        byte_count = SMC_GET3(esph->byte_count);
  95                 unsigned        elem_type = esph->element_type;
  96                 unsigned char * pgend = p + byte_count + 8;
  97                 int             PVolTag = 0;
  98                 int             AVolTag = 0;
  99
 100                 if (pgend > raw_end) {
 101                         /* malformed, really, but punt */
 102                         pgend = raw_end;
 103                 }
 104
 105                 if (esph->flag1 & SMC_RAW_ESP_F1_PVolTag)
 106                         PVolTag = 1;
 107                 if (esph->flag1 & SMC_RAW_ESP_F1_AVolTag)
 108                         AVolTag = 1;
 109
 110                 p += 8;
 111
 112                 for (;p + desc_size <= pgend; p += desc_size) {
 113                     struct smc_element_descriptor *edp;
 114
 115                     if (n_elem >= max_elem_desc) {
 116                         /* bust out */
 117                         goto done;
 118                     }
 119                     edp = &elem_desc[n_elem++];
 120                     WITH (p, red, struct smc_raw_element_descriptor)
 121                         unsigned char *p2;
 122
 123                         edp->element_type_code = elem_type;
 124                         edp->element_address = SMC_GET2(red->element_address);
 125                         edp->PVolTag = PVolTag;
 126                         edp->AVolTag = AVolTag;
 127 #define FLAG(RAWMEM,BIT,MEM) if (red->RAWMEM & BIT) edp->MEM = 1;
 128                         FLAG(flags2, SMC_RAW_ED_F2_Full, Full);
 129                         FLAG(flags2, SMC_RAW_ED_F2_ImpExp, ImpExp);
 130                         FLAG(flags2, SMC_RAW_ED_F2_Except, Except);
 131                         FLAG(flags2, SMC_RAW_ED_F2_Access, Access);
 132                         FLAG(flags2, SMC_RAW_ED_F2_ExEnab, ExEnab);
 133                         FLAG(flags2, SMC_RAW_ED_F2_InEnab, InEnab);
 134
 135                         edp->asc = red->asc;
 136                         edp->ascq = red->ascq;
 137
 138                         edp->scsi_lun = red->flags6 & 7;
 139                         FLAG(flags6, SMC_RAW_ED_F6_LU_valid, LU_valid);
 140                         FLAG(flags6, SMC_RAW_ED_F6_ID_valid, ID_valid);
 141                         FLAG(flags6, SMC_RAW_ED_F6_Not_bus, Not_bus);
 142
 143                         edp->scsi_sid = red->scsi_sid;
 144
 145                         FLAG(flags9, SMC_RAW_ED_F9_Invert, Invert);
 146                         FLAG(flags9, SMC_RAW_ED_F9_SValid, SValid);
 147 #undef FLAG
 148
 149                         edp->src_se_addr = SMC_GET2(red->src_se_addr);
 150
 151                         p2 = (unsigned char *) &red->primary_vol_tag;
 152                         if (edp->PVolTag) {
 153                                 smc_parse_volume_tag ((void*)p2,
 154                                                 &edp->primary_vol_tag);
 155                                 p2 += SMC_VOL_TAG_LEN;
 156                         }
 157                         if (edp->AVolTag) {
 158                                 smc_parse_volume_tag ((void*)p2,
 159                                                 &edp->alternate_vol_tag);
 160                                 p2 += SMC_VOL_TAG_LEN;
 161                         }
 162                         p2 += 4;        /* resv84 */
 163                         /* p2 ready for vendor_specific */
 164                     ENDWITH
 165                 }
 166                 p = pgend;
 167             ENDWITH
 168         }
 169
 170   done:
 171         return n_elem;
 172 }
 173
 174
 175
 176 int
 177 smc_parse_element_address_assignment (
 178   struct smc_raw_element_address_assignment_page *raw,
 179   struct smc_element_address_assignment *eaa)
 180 {
 181         eaa->mte_addr  = SMC_GET2(raw->mte_addr);
 182         eaa->mte_count = SMC_GET2(raw->mte_count);
 183         eaa->se_addr   = SMC_GET2(raw->se_addr);
 184         eaa->se_count  = SMC_GET2(raw->se_count);
 185         eaa->iee_addr  = SMC_GET2(raw->iee_addr);
 186         eaa->iee_count = SMC_GET2(raw->iee_count);
 187         eaa->dte_addr  = SMC_GET2(raw->dte_addr);
 188         eaa->dte_count = SMC_GET2(raw->dte_count);
 189
 190         return 0;
 191 }
 192