github.com/zartbot/goflow@v0.0.0-20221001080520-456f7dfad288/netflowv9/record.go (about)

     1  package netflowv9
     2  
     3  import (
     4  	"github.com/zartbot/goflow/datarecord"
     5  	"github.com/zartbot/goflow/iedb"
     6  	"github.com/zartbot/goflow/reader"
     7  )
     8  
     9  // FieldValueDecode :  FV decode function
    10  func FieldValueDecode(r *reader.Reader, tr *TemplateFieldSpecifier) (interface{}, error) {
    11  	var f interface{}
    12  	var err error
    13  	//f.Key = tr.Key
    14  	//f.Name = tr.Name
    15  	//f.Type = tr.Type
    16  
    17  	var tempValue []byte
    18  	tempValue, err = r.ReadN(tr.Length)
    19  	if err != nil {
    20  		return f, err
    21  	}
    22  
    23  	f = iedb.ConvertDataType(&tempValue, tr.Dtype)
    24  	return f, nil
    25  }
    26  
    27  /*
    28  func (f *FieldValue) String() string {
    29  	return fmt.Sprintf("ElementKey:+%v\t\tName:\t%s\t          \tType:\t%s\t           \t%+v\n", f.Key, f.Name, f.Type, f.Value)
    30  }
    31  */
    32  
    33  // DataRecordDecode : A method to parse DataRecord
    34  func DataRecordDecode(r *reader.Reader, AgentID string, LocalPort int, m *MessageHeader, s *FlowSetHeader) (datarecord.DataFrame, error) {
    35  	//d := datarecord.NewDataFrame()
    36  	d := &datarecord.DataFrame{}
    37  	var err error
    38  	var t TemplateRecord
    39  
    40  	d.AgentID = AgentID
    41  	d.DomainID = m.DomainID
    42  	d.ExportTime = m.ExportTime
    43  	d.SetID = s.SetID
    44  
    45  	t, err = FetchTemplateMap(d.AgentID, LocalPort, d.DomainID, d.SetID)
    46  	if err != nil {
    47  		//Template does not found, drop record
    48  		//logrus.Warn("Template does not found")
    49  		return *d, nil
    50  	}
    51  
    52  	initpos := r.Pos
    53  	var byteremain uint16
    54  	for {
    55  		data := make(map[string]interface{})
    56  
    57  		for idx := uint16(0); idx < t.Header.ScopeFieldCount; idx++ {
    58  			tr := t.ScopeFieldRecord[idx]
    59  			var fv interface{}
    60  			fv, err := FieldValueDecode(r, &tr)
    61  			if err != nil {
    62  				return *d, err
    63  			}
    64  			data[tr.Name] = fv
    65  		}
    66  		for idx := uint16(0); idx < t.Header.FieldCount; idx++ {
    67  			tr := t.FieldRecord[idx]
    68  			var fv interface{}
    69  			fv, err := FieldValueDecode(r, &tr)
    70  			if err != nil {
    71  				return *d, err
    72  			}
    73  			data[tr.Name] = fv
    74  		}
    75  		//handle NFv9 SysUpTime First/Last
    76  		FirstTime, ok1 := data["flowStartSysUpTime"]
    77  		LastTime, ok2 := data["flowEndSysUpTime"]
    78  
    79  		if ok1 && ok2 && (LastTime != nil) && (FirstTime != nil) {
    80  			first := FirstTime.(uint32)
    81  			last := LastTime.(uint32)
    82  			data["flowEndMilliseconds"] = uint64(last) + m.BootTime
    83  			if first > last {
    84  				data["flowStartMilliseconds"] = m.BootTime - uint64(100000000) + uint64(first)
    85  			} else {
    86  				data["flowStartMilliseconds"] = m.BootTime + uint64(first)
    87  			}
    88  		}
    89  
    90  		d.Record = append(d.Record, data)
    91  
    92  		//fmt.Printf("Recode Finished......\tFlowSetLength:%d\tRead_Pos:%d\tInitPos:%d\tAlreadyRead:%d\t\n", s.Length, r.Pos, initpos, r.Pos-initpos)
    93  
    94  		byteremain = s.Length - 4 - (r.Pos - initpos)
    95  		// RFC 7011 Section 3.3.1. Set Format
    96  		// Padding
    97  		//
    98  		// The Exporting Process MAY insert some padding octets, so that the
    99  		// subsequent Set starts at an aligned boundary.  For security
   100  		// reasons, the padding octet(s) MUST be composed of octets with
   101  		// value zero (0).  The padding length MUST be shorter than any
   102  		// allowable record in this Set.  If padding of the IPFIX Message is
   103  		// desired in combination with very short records, then the padding
   104  		// Information Element 'paddingOctets' can be used for padding
   105  		// records such that their length is increased to a multiple of 4 or
   106  		// 8 octets.  Because Template Sets are always 4-octet aligned by
   107  		// definition, padding is only needed in the case of other
   108  		// alignments, e.g., on 8-octet boundaries.
   109  
   110  		if byteremain < 4 {
   111  			//read padding...
   112  			if byteremain > 0 {
   113  				_, err = r.ReadN(byteremain)
   114  				if err != nil {
   115  					return *d, err
   116  				}
   117  			}
   118  			break
   119  		}
   120  	}
   121  
   122  	return *d, nil
   123  }