1 /******************************************************************************
3 * (C)Copyright 1998,1999 SysKonnect,
4 * a business unit of Schneider & Koch & Co. Datensysteme GmbH.
6 * See the file "skfddi.c" for further information.
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * The information in this file is provided "AS IS" without warranty.
15 ******************************************************************************/
18 Parameter Management Frame processing for SMT 7.2
27 #include "h/smtstate.h"
32 static const char ID_sccs
[] = "@(#)pmf.c 1.37 97/08/04 (C) SK " ;
35 static int smt_authorize(struct s_smc
*smc
, struct smt_header
*sm
);
36 static int smt_check_set_count(struct s_smc
*smc
, struct smt_header
*sm
);
37 static const struct s_p_tab
* smt_get_ptab(u_short para
);
38 static int smt_mib_phys(struct s_smc
*smc
);
39 static int smt_set_para(struct s_smc
*smc
, struct smt_para
*pa
, int index
,
41 void smt_add_para(struct s_smc
*smc
, struct s_pcon
*pcon
, u_short para
,
42 int index
, int local
);
43 static SMbuf
*smt_build_pmf_response(struct s_smc
*smc
, struct smt_header
*req
,
45 static int port_to_mib(struct s_smc
*smc
, int p
);
47 #define MOFFSS(e) offsetof(struct fddi_mib, e)
48 #define MOFFMS(e) offsetof(struct fddi_mib_m, e)
49 #define MOFFAS(e) offsetof(struct fddi_mib_a, e)
50 #define MOFFPS(e) offsetof(struct fddi_mib_p, e)
53 #define AC_G 0x01 /* Get */
54 #define AC_GR 0x02 /* Get/Set */
55 #define AC_S 0x04 /* Set */
57 #define AC_GROUP 0x10 /* Group */
58 #define MS2BCLK(x) ((x)*12500L)
67 A LongAddress (6 byte)
71 static const struct s_p_tab
{
72 u_short p_num
; /* parameter code */
73 u_char p_access
; /* access rights */
74 u_short p_offset
; /* offset in mib */
75 char p_swap
[3] ; /* format string */
78 { SMT_P100A
,AC_GROUP
} ,
79 { SMT_P100B
,AC_G
, MOFFSS(fddiSMTStationId
), "8" } ,
80 { SMT_P100D
,AC_G
, MOFFSS(fddiSMTOpVersionId
), "S" } ,
81 { SMT_P100E
,AC_G
, MOFFSS(fddiSMTHiVersionId
), "S" } ,
82 { SMT_P100F
,AC_G
, MOFFSS(fddiSMTLoVersionId
), "S" } ,
83 { SMT_P1010
,AC_G
, MOFFSS(fddiSMTManufacturerData
), "D" } ,
84 { SMT_P1011
,AC_GR
, MOFFSS(fddiSMTUserData
), "D" } ,
85 { SMT_P1012
,AC_G
, MOFFSS(fddiSMTMIBVersionId
), "S" } ,
87 /* StationConfigGrp */
88 { SMT_P1014
,AC_GROUP
} ,
89 { SMT_P1015
,AC_G
, MOFFSS(fddiSMTMac_Ct
), "B" } ,
90 { SMT_P1016
,AC_G
, MOFFSS(fddiSMTNonMaster_Ct
), "B" } ,
91 { SMT_P1017
,AC_G
, MOFFSS(fddiSMTMaster_Ct
), "B" } ,
92 { SMT_P1018
,AC_G
, MOFFSS(fddiSMTAvailablePaths
), "B" } ,
93 { SMT_P1019
,AC_G
, MOFFSS(fddiSMTConfigCapabilities
),"S" } ,
94 { SMT_P101A
,AC_GR
, MOFFSS(fddiSMTConfigPolicy
), "wS" } ,
95 { SMT_P101B
,AC_GR
, MOFFSS(fddiSMTConnectionPolicy
),"wS" } ,
96 { SMT_P101D
,AC_GR
, MOFFSS(fddiSMTTT_Notify
), "wS" } ,
97 { SMT_P101E
,AC_GR
, MOFFSS(fddiSMTStatRptPolicy
), "bB" } ,
98 { SMT_P101F
,AC_GR
, MOFFSS(fddiSMTTrace_MaxExpiration
),"lL" } ,
99 { SMT_P1020
,AC_G
, MOFFSS(fddiSMTPORTIndexes
), "II" } ,
100 { SMT_P1021
,AC_G
, MOFFSS(fddiSMTMACIndexes
), "I" } ,
101 { SMT_P1022
,AC_G
, MOFFSS(fddiSMTBypassPresent
), "F" } ,
104 { SMT_P1028
,AC_GROUP
} ,
105 { SMT_P1029
,AC_G
, MOFFSS(fddiSMTECMState
), "E" } ,
106 { SMT_P102A
,AC_G
, MOFFSS(fddiSMTCF_State
), "E" } ,
107 { SMT_P102C
,AC_G
, MOFFSS(fddiSMTRemoteDisconnectFlag
),"F" } ,
108 { SMT_P102D
,AC_G
, MOFFSS(fddiSMTStationStatus
), "E" } ,
109 { SMT_P102E
,AC_G
, MOFFSS(fddiSMTPeerWrapFlag
), "F" } ,
111 /* MIBOperationGrp */
112 { SMT_P1032
,AC_GROUP
} ,
113 { SMT_P1033
,AC_G
, MOFFSS(fddiSMTTimeStamp
),"P" } ,
114 { SMT_P1034
,AC_G
, MOFFSS(fddiSMTTransitionTimeStamp
),"P" } ,
115 /* NOTE : SMT_P1035 is already swapped ! SMT_P_SETCOUNT */
116 { SMT_P1035
,AC_G
, MOFFSS(fddiSMTSetCount
),"4P" } ,
117 { SMT_P1036
,AC_G
, MOFFSS(fddiSMTLastSetStationId
),"8" } ,
119 { SMT_P103C
,AC_S
, 0, "wS" } ,
123 * only accessible locally to get/set passwd
125 { SMT_P10F0
,AC_GR
, MOFFSS(fddiPRPMFPasswd
), "8" } ,
126 { SMT_P10F1
,AC_GR
, MOFFSS(fddiPRPMFStation
), "8" } ,
128 { SMT_P10F2
,AC_GR
, MOFFSS(fddiESSPayload
), "lL" } ,
129 { SMT_P10F3
,AC_GR
, MOFFSS(fddiESSOverhead
), "lL" } ,
130 { SMT_P10F4
,AC_GR
, MOFFSS(fddiESSMaxTNeg
), "lL" } ,
131 { SMT_P10F5
,AC_GR
, MOFFSS(fddiESSMinSegmentSize
), "lL" } ,
132 { SMT_P10F6
,AC_GR
, MOFFSS(fddiESSCategory
), "lL" } ,
133 { SMT_P10F7
,AC_GR
, MOFFSS(fddiESSSynchTxMode
), "wS" } ,
136 { SMT_P10F8
,AC_GR
, MOFFSS(fddiSBACommand
), "bF" } ,
137 { SMT_P10F9
,AC_GR
, MOFFSS(fddiSBAAvailable
), "bF" } ,
140 { SMT_P200A
,AC_GROUP
} ,
141 { SMT_P200B
,AC_G
, MOFFMS(fddiMACFrameStatusFunctions
),"S" } ,
142 { SMT_P200D
,AC_G
, MOFFMS(fddiMACT_MaxCapabilitiy
),"T" } ,
143 { SMT_P200E
,AC_G
, MOFFMS(fddiMACTVXCapabilitiy
),"T" } ,
146 { SMT_P2014
,AC_GROUP
} ,
147 { SMT_P2016
,AC_G
, MOFFMS(fddiMACAvailablePaths
), "B" } ,
148 { SMT_P2017
,AC_G
, MOFFMS(fddiMACCurrentPath
), "S" } ,
149 { SMT_P2018
,AC_G
, MOFFMS(fddiMACUpstreamNbr
), "A" } ,
150 { SMT_P2019
,AC_G
, MOFFMS(fddiMACDownstreamNbr
), "A" } ,
151 { SMT_P201A
,AC_G
, MOFFMS(fddiMACOldUpstreamNbr
), "A" } ,
152 { SMT_P201B
,AC_G
, MOFFMS(fddiMACOldDownstreamNbr
),"A" } ,
153 { SMT_P201D
,AC_G
, MOFFMS(fddiMACDupAddressTest
), "E" } ,
154 { SMT_P2020
,AC_GR
, MOFFMS(fddiMACRequestedPaths
), "wS" } ,
155 { SMT_P2021
,AC_G
, MOFFMS(fddiMACDownstreamPORTType
),"E" } ,
156 { SMT_P2022
,AC_G
, MOFFMS(fddiMACIndex
), "S" } ,
159 { SMT_P2028
,AC_GROUP
} ,
160 { SMT_P2029
,AC_G
, MOFFMS(fddiMACSMTAddress
), "A" } ,
163 { SMT_P2032
,AC_GROUP
} ,
164 { SMT_P2033
,AC_G
, MOFFMS(fddiMACT_Req
), "T" } ,
165 { SMT_P2034
,AC_G
, MOFFMS(fddiMACT_Neg
), "T" } ,
166 { SMT_P2035
,AC_G
, MOFFMS(fddiMACT_Max
), "T" } ,
167 { SMT_P2036
,AC_G
, MOFFMS(fddiMACTvxValue
), "T" } ,
168 { SMT_P2038
,AC_G
, MOFFMS(fddiMACT_Pri0
), "T" } ,
169 { SMT_P2039
,AC_G
, MOFFMS(fddiMACT_Pri1
), "T" } ,
170 { SMT_P203A
,AC_G
, MOFFMS(fddiMACT_Pri2
), "T" } ,
171 { SMT_P203B
,AC_G
, MOFFMS(fddiMACT_Pri3
), "T" } ,
172 { SMT_P203C
,AC_G
, MOFFMS(fddiMACT_Pri4
), "T" } ,
173 { SMT_P203D
,AC_G
, MOFFMS(fddiMACT_Pri5
), "T" } ,
174 { SMT_P203E
,AC_G
, MOFFMS(fddiMACT_Pri6
), "T" } ,
178 { SMT_P2046
,AC_GROUP
} ,
179 { SMT_P2047
,AC_G
, MOFFMS(fddiMACFrame_Ct
), "C" } ,
180 { SMT_P2048
,AC_G
, MOFFMS(fddiMACCopied_Ct
), "C" } ,
181 { SMT_P2049
,AC_G
, MOFFMS(fddiMACTransmit_Ct
), "C" } ,
182 { SMT_P204A
,AC_G
, MOFFMS(fddiMACToken_Ct
), "C" } ,
183 { SMT_P2051
,AC_G
, MOFFMS(fddiMACError_Ct
), "C" } ,
184 { SMT_P2052
,AC_G
, MOFFMS(fddiMACLost_Ct
), "C" } ,
185 { SMT_P2053
,AC_G
, MOFFMS(fddiMACTvxExpired_Ct
), "C" } ,
186 { SMT_P2054
,AC_G
, MOFFMS(fddiMACNotCopied_Ct
), "C" } ,
187 { SMT_P2056
,AC_G
, MOFFMS(fddiMACRingOp_Ct
), "C" } ,
189 /* FrameErrorConditionGrp */
190 { SMT_P205A
,AC_GROUP
} ,
191 { SMT_P205F
,AC_GR
, MOFFMS(fddiMACFrameErrorThreshold
),"wS" } ,
192 { SMT_P2060
,AC_G
, MOFFMS(fddiMACFrameErrorRatio
), "S" } ,
194 /* NotCopiedConditionGrp */
195 { SMT_P2064
,AC_GROUP
} ,
196 { SMT_P2067
,AC_GR
, MOFFMS(fddiMACNotCopiedThreshold
),"wS" } ,
197 { SMT_P2069
,AC_G
, MOFFMS(fddiMACNotCopiedRatio
), "S" } ,
200 { SMT_P206E
,AC_GROUP
} ,
201 { SMT_P206F
,AC_G
, MOFFMS(fddiMACRMTState
), "S" } ,
202 { SMT_P2070
,AC_G
, MOFFMS(fddiMACDA_Flag
), "F" } ,
203 { SMT_P2071
,AC_G
, MOFFMS(fddiMACUNDA_Flag
), "F" } ,
204 { SMT_P2072
,AC_G
, MOFFMS(fddiMACFrameErrorFlag
), "F" } ,
205 { SMT_P2073
,AC_G
, MOFFMS(fddiMACNotCopiedFlag
), "F" } ,
206 { SMT_P2074
,AC_G
, MOFFMS(fddiMACMA_UnitdataAvailable
),"F" } ,
207 { SMT_P2075
,AC_G
, MOFFMS(fddiMACHardwarePresent
), "F" } ,
208 { SMT_P2076
,AC_GR
, MOFFMS(fddiMACMA_UnitdataEnable
),"bF" } ,
212 * only accessible locally to get/set TMIN
214 { SMT_P20F0
,AC_NA
} ,
215 { SMT_P20F1
,AC_GR
, MOFFMS(fddiMACT_Min
), "lT" } ,
217 /* Path Attributes */
219 * DON't swap 320B,320F,3210: they are already swapped in swap_para()
221 { SMT_P320A
,AC_GROUP
} ,
222 { SMT_P320B
,AC_G
, MOFFAS(fddiPATHIndex
), "r" } ,
223 { SMT_P320F
,AC_GR
, MOFFAS(fddiPATHSbaPayload
), "l4" } ,
224 { SMT_P3210
,AC_GR
, MOFFAS(fddiPATHSbaOverhead
), "l4" } ,
225 /* fddiPATHConfiguration */
226 { SMT_P3212
,AC_G
, 0, "" } ,
227 { SMT_P3213
,AC_GR
, MOFFAS(fddiPATHT_Rmode
), "lT" } ,
228 { SMT_P3214
,AC_GR
, MOFFAS(fddiPATHSbaAvailable
), "lL" } ,
229 { SMT_P3215
,AC_GR
, MOFFAS(fddiPATHTVXLowerBound
), "lT" } ,
230 { SMT_P3216
,AC_GR
, MOFFAS(fddiPATHT_MaxLowerBound
),"lT" } ,
231 { SMT_P3217
,AC_GR
, MOFFAS(fddiPATHMaxT_Req
), "lT" } ,
233 /* Port Attributes */
235 { SMT_P400A
,AC_GROUP
} ,
236 { SMT_P400C
,AC_G
, MOFFPS(fddiPORTMy_Type
), "E" } ,
237 { SMT_P400D
,AC_G
, MOFFPS(fddiPORTNeighborType
), "E" } ,
238 { SMT_P400E
,AC_GR
, MOFFPS(fddiPORTConnectionPolicies
),"bB" } ,
239 { SMT_P400F
,AC_G
, MOFFPS(fddiPORTMacIndicated
), "2" } ,
240 { SMT_P4010
,AC_G
, MOFFPS(fddiPORTCurrentPath
), "E" } ,
241 { SMT_P4011
,AC_GR
, MOFFPS(fddiPORTRequestedPaths
), "l4" } ,
242 { SMT_P4012
,AC_G
, MOFFPS(fddiPORTMACPlacement
), "S" } ,
243 { SMT_P4013
,AC_G
, MOFFPS(fddiPORTAvailablePaths
), "B" } ,
244 { SMT_P4016
,AC_G
, MOFFPS(fddiPORTPMDClass
), "E" } ,
245 { SMT_P4017
,AC_G
, MOFFPS(fddiPORTConnectionCapabilities
), "B"} ,
246 { SMT_P401D
,AC_G
, MOFFPS(fddiPORTIndex
), "R" } ,
249 { SMT_P401E
,AC_GROUP
} ,
250 { SMT_P401F
,AC_GR
, MOFFPS(fddiPORTMaint_LS
), "wE" } ,
251 { SMT_P4021
,AC_G
, MOFFPS(fddiPORTBS_Flag
), "F" } ,
252 { SMT_P4022
,AC_G
, MOFFPS(fddiPORTPC_LS
), "E" } ,
255 { SMT_P4028
,AC_GROUP
} ,
256 { SMT_P4029
,AC_G
, MOFFPS(fddiPORTEBError_Ct
), "C" } ,
257 { SMT_P402A
,AC_G
, MOFFPS(fddiPORTLCTFail_Ct
), "C" } ,
260 { SMT_P4032
,AC_GROUP
} ,
261 { SMT_P4033
,AC_G
, MOFFPS(fddiPORTLer_Estimate
), "F" } ,
262 { SMT_P4034
,AC_G
, MOFFPS(fddiPORTLem_Reject_Ct
), "C" } ,
263 { SMT_P4035
,AC_G
, MOFFPS(fddiPORTLem_Ct
), "C" } ,
264 { SMT_P403A
,AC_GR
, MOFFPS(fddiPORTLer_Cutoff
), "bB" } ,
265 { SMT_P403B
,AC_GR
, MOFFPS(fddiPORTLer_Alarm
), "bB" } ,
268 { SMT_P403C
,AC_GROUP
} ,
269 { SMT_P403D
,AC_G
, MOFFPS(fddiPORTConnectState
), "E" } ,
270 { SMT_P403E
,AC_G
, MOFFPS(fddiPORTPCMStateX
), "E" } ,
271 { SMT_P403F
,AC_G
, MOFFPS(fddiPORTPC_Withhold
), "E" } ,
272 { SMT_P4040
,AC_G
, MOFFPS(fddiPORTLerFlag
), "F" } ,
273 { SMT_P4041
,AC_G
, MOFFPS(fddiPORTHardwarePresent
),"F" } ,
275 { SMT_P4046
,AC_S
, 0, "wS" } ,
281 void smt_pmf_received_pack(struct s_smc
*smc
, SMbuf
*mb
, int local
)
283 struct smt_header
*sm
;
286 sm
= smtod(mb
,struct smt_header
*) ;
287 DB_SMT("SMT: processing PMF frame at %p len %d\n",sm
,mb
->sm_len
) ;
289 dump_smt(smc
,sm
,"PMF Received") ;
292 * Start the watchdog: It may be a long, long packet and
293 * maybe the watchdog occurs ...
295 smt_start_watchdog(smc
) ;
297 if (sm
->smt_class
== SMT_PMF_GET
||
298 sm
->smt_class
== SMT_PMF_SET
) {
299 reply
= smt_build_pmf_response(smc
,sm
,
300 sm
->smt_class
== SMT_PMF_SET
,local
) ;
302 sm
= smtod(reply
,struct smt_header
*) ;
304 dump_smt(smc
,sm
,"PMF Reply") ;
306 smt_send_frame(smc
,reply
,FC_SMT_INFO
,local
) ;
311 static SMbuf
*smt_build_pmf_response(struct s_smc
*smc
, struct smt_header
*req
,
315 struct smt_header
*smt
;
316 struct smt_para
*pa
;
317 struct smt_p_reason
*res
;
318 const struct s_p_tab
*pt
;
324 SK_LOC_DECL(struct s_pcon
,pcon
) ;
325 SK_LOC_DECL(struct s_pcon
,set_pcon
) ;
330 if (!(mb
= smt_get_mbuf(smc
)))
333 smt
= smtod(mb
, struct smt_header
*) ;
334 smt
->smt_dest
= req
->smt_source
; /* DA == source of request */
335 smt
->smt_class
= req
->smt_class
; /* same class (GET/SET) */
336 smt
->smt_type
= SMT_REPLY
;
337 smt
->smt_version
= SMT_VID_2
;
338 smt
->smt_tid
= req
->smt_tid
; /* same TID */
343 * setup parameter status
345 pcon
.pc_len
= SMT_MAX_INFO_LEN
; /* max para length */
346 pcon
.pc_err
= 0 ; /* no error */
347 pcon
.pc_badset
= 0 ; /* no bad set count */
348 pcon
.pc_p
= (void *) (smt
+ 1) ; /* paras start here */
351 * check authoriziation and set count
355 if (!local
&& smt_authorize(smc
,req
))
356 error
= SMT_RDF_AUTHOR
;
357 else if (smt_check_set_count(smc
,req
))
358 pcon
.pc_badset
= SMT_RDF_BADSET
;
361 * add reason code and all mandatory parameters
363 res
= (struct smt_p_reason
*) pcon
.pc_p
;
364 smt_add_para(smc
,&pcon
,(u_short
) SMT_P_REASON
,0,0) ;
365 smt_add_para(smc
,&pcon
,(u_short
) SMT_P1033
,0,0) ;
366 /* update 1035 and 1036 later if set */
368 smt_add_para(smc
,&pcon
,(u_short
) SMT_P1035
,0,0) ;
369 smt_add_para(smc
,&pcon
,(u_short
) SMT_P1036
,0,0) ;
371 pcon
.pc_err
= error
;
373 pa
= (struct smt_para
*) (req
+ 1) ;
375 * process list of paras
377 while (!pcon
.pc_err
&& len
> 0 ) {
378 if (((u_short
)len
< pa
->p_len
+ PARA_LEN
) || (pa
->p_len
& 3)) {
379 pcon
.pc_err
= SMT_RDF_LENGTH
;
383 if (((range
= (pa
->p_type
& 0xf000)) == 0x2000) ||
384 range
== 0x3000 || range
== 0x4000) {
386 * get index for PART,MAC ad PATH group
388 index
= *((u_char
*)pa
+ PARA_LEN
+ 3) ;/* index */
390 if (!set
&& (pa
->p_len
!= 4)) {
391 pcon
.pc_err
= SMT_RDF_LENGTH
;
394 if (!index
&& !set
) {
398 idx_end
= index
- 1 + NUMMACS
;
402 idx_end
= index
- 1 + NUMPATHS
;
406 idx_end
= index
- 1 + NUMPHYS
;
408 if (smc
->s
.sas
== SMT_SAS
)
409 idx_end
= INDEX_PORT
;
417 * smt group has no index
419 if (!set
&& (pa
->p_len
!= 0)) {
420 pcon
.pc_err
= SMT_RDF_LENGTH
;
426 while (index
<= idx_end
) {
429 * add all paras of group
431 pt
= smt_get_ptab(pa
->p_type
) ;
432 if (pt
&& pt
->p_access
== AC_GROUP
&& !set
) {
434 while (pt
->p_access
== AC_G
||
435 pt
->p_access
== AC_GR
) {
436 smt_add_para(smc
,&pcon
,pt
->p_num
,
443 * AUTHORIZATION in get/set
446 else if (pa
->p_type
!= SMT_P_AUTHOR
&&
447 (!set
|| (pa
->p_type
!= SMT_P1035
))) {
449 if (pcon
.pc_badset
) {
450 smt_add_para(smc
,&pcon
,pa
->p_type
,
454 st
= smt_set_para(smc
,pa
,index
,local
,1);
456 * return para even if error
458 smt_add_para(smc
,&pcon
,pa
->p_type
,
463 if (pt
&& pt
->p_access
== AC_S
) {
467 smt_add_para(smc
,&pcon
,pa
->p_type
,
475 len
-= pa
->p_len
+ PARA_LEN
;
476 pa
= (struct smt_para
*) ((char *)pa
+ pa
->p_len
+ PARA_LEN
) ;
478 smt
->smt_len
= SMT_MAX_INFO_LEN
- pcon
.pc_len
;
479 mb
->sm_len
= smt
->smt_len
+ sizeof(struct smt_header
) ;
481 /* update reason code */
482 res
->rdf_reason
= pcon
.pc_badset
? pcon
.pc_badset
:
483 pcon
.pc_err
? pcon
.pc_err
: SMT_RDF_SUCCESS
;
484 if (set
&& (res
->rdf_reason
== SMT_RDF_SUCCESS
)) {
486 * increment set count
488 * store station id of last set
490 smc
->mib
.fddiSMTSetCount
.count
++ ;
491 smt_set_timestamp(smc
,smc
->mib
.fddiSMTSetCount
.timestamp
) ;
492 smc
->mib
.fddiSMTLastSetStationId
= req
->smt_sid
;
493 smt_add_para(smc
,&set_pcon
,(u_short
) SMT_P1035
,0,0) ;
494 smt_add_para(smc
,&set_pcon
,(u_short
) SMT_P1036
,0,0) ;
499 static int smt_authorize(struct s_smc
*smc
, struct smt_header
*sm
)
501 struct smt_para
*pa
;
506 * check source station id if not zero
508 p
= (char *) &smc
->mib
.fddiPRPMFStation
;
509 for (i
= 0 ; i
< 8 && !p
[i
] ; i
++)
512 if (memcmp((char *) &sm
->smt_sid
,
513 (char *) &smc
->mib
.fddiPRPMFStation
,8))
517 * check authoriziation parameter if passwd not zero
519 p
= (char *) smc
->mib
.fddiPRPMFPasswd
;
520 for (i
= 0 ; i
< 8 && !p
[i
] ; i
++)
523 pa
= (struct smt_para
*) sm_to_para(smc
,sm
,SMT_P_AUTHOR
) ;
528 if (memcmp((char *)(pa
+1),(char *)smc
->mib
.fddiPRPMFPasswd
,8))
534 static int smt_check_set_count(struct s_smc
*smc
, struct smt_header
*sm
)
536 struct smt_para
*pa
;
537 struct smt_p_setcount
*sc
;
539 pa
= (struct smt_para
*) sm_to_para(smc
,sm
,SMT_P1035
) ;
541 sc
= (struct smt_p_setcount
*) pa
;
542 if ((smc
->mib
.fddiSMTSetCount
.count
!= sc
->count
) ||
543 memcmp((char *) smc
->mib
.fddiSMTSetCount
.timestamp
,
544 (char *)sc
->timestamp
,8))
550 void smt_add_para(struct s_smc
*smc
, struct s_pcon
*pcon
, u_short para
,
551 int index
, int local
)
553 struct smt_para
*pa
;
554 const struct s_p_tab
*pt
;
555 struct fddi_mib_m
*mib_m
= NULL
;
556 struct fddi_mib_p
*mib_p
= NULL
;
577 * actions don't have a value
579 pt
= smt_get_ptab(para
) ;
580 if (pt
&& pt
->p_access
== AC_S
)
583 to
= (char *) (pcon
->pc_p
) ; /* destination pointer */
584 len
= pcon
->pc_len
; /* free space */
585 plen
= len
; /* remember start length */
586 pa
= (struct smt_para
*) to
; /* type/length pointer */
587 to
+= PARA_LEN
; /* skip smt_para */
590 * set index if required
592 if (((range
= (para
& 0xf000)) == 0x2000) ||
593 range
== 0x3000 || range
== 0x4000) {
603 mac
= index
- INDEX_MAC
;
604 path
= index
- INDEX_PATH
;
605 port
= index
- INDEX_PORT
;
612 mib_addr
= (char *) (&smc
->mib
) ;
615 if (mac
< 0 || mac
>= NUMMACS
) {
616 pcon
->pc_err
= SMT_RDF_NOPARAM
;
619 mib_addr
= (char *) (&smc
->mib
.m
[mac
]) ;
620 mib_m
= (struct fddi_mib_m
*) mib_addr
;
623 if (path
< 0 || path
>= NUMPATHS
) {
624 pcon
->pc_err
= SMT_RDF_NOPARAM
;
627 mib_addr
= (char *) (&smc
->mib
.a
[path
]) ;
630 if (port
< 0 || port
>= smt_mib_phys(smc
)) {
631 pcon
->pc_err
= SMT_RDF_NOPARAM
;
634 mib_addr
= (char *) (&smc
->mib
.p
[port_to_mib(smc
,port
)]) ;
635 mib_p
= (struct fddi_mib_p
*) mib_addr
;
639 * check special paras
659 pcon
->pc_err
= SMT_RDF_NOPARAM
;
669 mac_update_counter(smc
) ;
672 mib_p
->fddiPORTPC_LS
= LS2MIB(
673 sm_pm_get_ls(smc
,port_to_mib(smc
,port
))) ;
679 case SMT_P1033
: /* time stamp */
680 smt_set_timestamp(smc
,smc
->mib
.fddiSMTTimeStamp
) ;
683 case SMT_P1020
: /* port indexes */
685 swap
= "IIIIIIIIIIII" ;
688 if (smc
->s
.sas
== SMT_SAS
)
694 swap
= "IIIIIIIIIIIIIIIIIIIIIIII" ;
703 sp_len
= cem_build_path(smc
,to
,path
) ;
706 case SMT_P1048
: /* peer wrap condition */
708 struct smt_p_1048
*sp
;
709 sp
= (struct smt_p_1048
*) to
;
710 sp
->p1048_flag
= smc
->mib
.fddiSMTPeerWrapFlag
;
711 sp
->p1048_cf_state
= smc
->mib
.fddiSMTCF_State
;
712 sp_len
= sizeof(struct smt_p_1048
) ;
717 struct smt_p_208c
*sp
;
718 sp
= (struct smt_p_208c
*) to
;
720 smc
->mib
.m
[MAC0
].fddiMACDuplicateAddressCond
;
721 sp
->p208c_dupcondition
=
722 (mib_m
->fddiMACDA_Flag
? SMT_ST_MY_DUPA
: 0) |
723 (mib_m
->fddiMACUNDA_Flag
? SMT_ST_UNA_DUPA
: 0);
725 mib_m
->fddiMACSMTAddress
;
726 sp
->p208c_fddiunalong
=
727 mib_m
->fddiMACUpstreamNbr
;
729 sp_len
= sizeof(struct smt_p_208c
) ;
732 case SMT_P208D
: /* frame error condition */
734 struct smt_p_208d
*sp
;
735 sp
= (struct smt_p_208d
*) to
;
737 mib_m
->fddiMACFrameErrorFlag
;
739 mib_m
->fddiMACFrame_Ct
;
741 mib_m
->fddiMACError_Ct
;
743 mib_m
->fddiMACLost_Ct
;
745 mib_m
->fddiMACFrameErrorRatio
;
746 sp_len
= sizeof(struct smt_p_208d
) ;
749 case SMT_P208E
: /* not copied condition */
751 struct smt_p_208e
*sp
;
752 sp
= (struct smt_p_208e
*) to
;
754 mib_m
->fddiMACNotCopiedFlag
;
755 sp
->p208e_not_copied
=
756 mib_m
->fddiMACNotCopied_Ct
;
758 mib_m
->fddiMACCopied_Ct
;
759 sp
->p208e_not_copied_ratio
=
760 mib_m
->fddiMACNotCopiedRatio
;
761 sp_len
= sizeof(struct smt_p_208e
) ;
764 case SMT_P208F
: /* neighbor change event */
766 struct smt_p_208f
*sp
;
767 sp
= (struct smt_p_208f
*) to
;
769 mib_m
->fddiMACMultiple_N
;
770 sp
->p208f_nacondition
=
771 mib_m
->fddiMACDuplicateAddressCond
;
773 mib_m
->fddiMACOldUpstreamNbr
;
775 mib_m
->fddiMACUpstreamNbr
;
777 mib_m
->fddiMACOldDownstreamNbr
;
779 mib_m
->fddiMACDownstreamNbr
;
780 sp
->p208f_curren_path
=
781 mib_m
->fddiMACCurrentPath
;
782 sp
->p208f_smt_address
=
783 mib_m
->fddiMACSMTAddress
;
784 sp_len
= sizeof(struct smt_p_208f
) ;
789 struct smt_p_2090
*sp
;
790 sp
= (struct smt_p_2090
*) to
;
792 mib_m
->fddiMACMultiple_P
;
793 sp
->p2090_availablepaths
=
794 mib_m
->fddiMACAvailablePaths
;
795 sp
->p2090_currentpath
=
796 mib_m
->fddiMACCurrentPath
;
797 sp
->p2090_requestedpaths
=
798 mib_m
->fddiMACRequestedPaths
;
799 sp_len
= sizeof(struct smt_p_2090
) ;
804 struct smt_p_4050
*sp
;
805 sp
= (struct smt_p_4050
*) to
;
807 mib_p
->fddiPORTLerFlag
;
810 mib_p
->fddiPORTLer_Cutoff
;
812 mib_p
->fddiPORTLer_Alarm
;
814 mib_p
->fddiPORTLer_Estimate
;
815 sp
->p4050_reject_ct
=
816 mib_p
->fddiPORTLem_Reject_Ct
;
818 mib_p
->fddiPORTLem_Ct
;
819 sp_len
= sizeof(struct smt_p_4050
) ;
825 struct smt_p_4051
*sp
;
826 sp
= (struct smt_p_4051
*) to
;
828 mib_p
->fddiPORTMultiple_U
;
830 mib_p
->fddiPORTMy_Type
;
831 sp
->p4051_connectstate
=
832 mib_p
->fddiPORTConnectState
;
833 sp
->p4051_pc_neighbor
=
834 mib_p
->fddiPORTNeighborType
;
835 sp
->p4051_pc_withhold
=
836 mib_p
->fddiPORTPC_Withhold
;
837 sp_len
= sizeof(struct smt_p_4051
) ;
842 struct smt_p_4052
*sp
;
843 sp
= (struct smt_p_4052
*) to
;
845 mib_p
->fddiPORTEB_Condition
;
846 sp
->p4052_eberrorcount
=
847 mib_p
->fddiPORTEBError_Ct
;
848 sp_len
= sizeof(struct smt_p_4052
) ;
853 struct smt_p_4053
*sp
;
854 sp
= (struct smt_p_4053
*) to
;
856 mib_p
->fddiPORTMultiple_P
;
857 sp
->p4053_availablepaths
=
858 mib_p
->fddiPORTAvailablePaths
;
859 sp
->p4053_currentpath
=
860 mib_p
->fddiPORTCurrentPath
;
861 memcpy( (char *) &sp
->p4053_requestedpaths
,
862 (char *) mib_p
->fddiPORTRequestedPaths
,4) ;
864 mib_p
->fddiPORTMy_Type
;
865 sp
->p4053_neighbortype
=
866 mib_p
->fddiPORTNeighborType
;
867 sp_len
= sizeof(struct smt_p_4053
) ;
877 pcon
->pc_err
= (para
& 0xff00) ? SMT_RDF_NOPARAM
:
882 * check access rights
884 switch (pt
->p_access
) {
889 pcon
->pc_err
= SMT_RDF_ILLEGAL
;
892 from
= mib_addr
+ pt
->p_offset
;
894 swap
= pt
->p_swap
; /* pointer to swap string */
899 while ((c
= *swap
++)) {
929 case 'I' : /* for SET of port indexes */
972 case '2' : /* PortMacIndicated */
997 memcpy((char *) to
+2,(char *) from
,6) ;
1005 memcpy((char *) to
,(char *) from
,8) ;
1013 memcpy((char *) to
,(char *) from
,32) ;
1018 case 'P' : /* timestamp is NOT swapped */
1033 SMT_PANIC(smc
,SMT_E0119
, SMT_E0119_MSG
) ;
1040 * make it even (in case of 'I' encoding)
1041 * note: len is DECREMENTED
1046 to
+= 4 - (len
& 3 ) ;
1050 /* set type and length */
1052 pa
->p_len
= plen
- len
- PARA_LEN
;
1054 pcon
->pc_p
= (void *) to
;
1055 pcon
->pc_len
= len
;
1064 /* parameter does not fit in frame */
1065 pcon
->pc_err
= SMT_RDF_TOOLONG
;
1069 pcon
->pc_err
= SMT_RDF_LENGTH
;
1075 static int smt_set_para(struct s_smc
*smc
, struct smt_para
*pa
, int index
,
1078 #define IFSET(x) if (set) (x)
1080 const struct s_p_tab
*pt
;
1087 struct fddi_mib
*mib
;
1088 struct fddi_mib_m
*mib_m
= NULL
;
1089 struct fddi_mib_a
*mib_a
= NULL
;
1090 struct fddi_mib_p
*mib_p
= NULL
;
1094 SK_LOC_DECL(u_char
,byte_val
) ;
1095 SK_LOC_DECL(u_short
,word_val
) ;
1096 SK_LOC_DECL(u_long
,long_val
) ;
1098 mac
= index
- INDEX_MAC
;
1099 path
= index
- INDEX_PATH
;
1100 port
= index
- INDEX_PORT
;
1102 from
= (char *) (pa
+ 1 ) ;
1105 switch (pa
->p_type
& 0xf000) {
1108 mib_addr
= (char *) mib
;
1111 if (mac
< 0 || mac
>= NUMMACS
) {
1112 return SMT_RDF_NOPARAM
;
1114 mib_m
= &smc
->mib
.m
[mac
] ;
1115 mib_addr
= (char *) mib_m
;
1116 from
+= 4 ; /* skip index */
1120 if (path
< 0 || path
>= NUMPATHS
) {
1121 return SMT_RDF_NOPARAM
;
1123 mib_a
= &smc
->mib
.a
[path
] ;
1124 mib_addr
= (char *) mib_a
;
1125 from
+= 4 ; /* skip index */
1129 if (port
< 0 || port
>= smt_mib_phys(smc
)) {
1130 return SMT_RDF_NOPARAM
;
1132 mib_p
= &smc
->mib
.p
[port_to_mib(smc
,port
)] ;
1133 mib_addr
= (char *) mib_p
;
1134 from
+= 4 ; /* skip index */
1138 switch (pa
->p_type
) {
1155 return SMT_RDF_NOPARAM
;
1158 pt
= smt_get_ptab(pa
->p_type
) ;
1160 return (pa
->p_type
& 0xff00) ? SMT_RDF_NOPARAM
:
1162 switch (pt
->p_access
) {
1167 return SMT_RDF_ILLEGAL
;
1169 to
= mib_addr
+ pt
->p_offset
;
1170 swap
= pt
->p_swap
; /* pointer to swap string */
1172 while (swap
&& (c
= *swap
++)) {
1175 to
= (char *) &byte_val
;
1178 to
= (char *) &word_val
;
1181 to
= (char *) &long_val
;
1190 if (from
[0] | from
[1])
1192 #ifdef LITTLE_ENDIAN
1214 if (from
[0] | from
[1] | from
[2])
1227 #ifdef LITTLE_ENDIAN
1245 memcpy(to
,from
+2,6) ;
1272 memcpy(to
,from
,32) ;
1277 case 'P' : /* timestamp is NOT swapped */
1292 SMT_PANIC(smc
,SMT_E0120
, SMT_E0120_MSG
) ;
1293 return SMT_RDF_ILLEGAL
;
1297 * actions and internal updates
1299 switch (pa
->p_type
) {
1300 case SMT_P101A
: /* fddiSMTConfigPolicy */
1303 IFSET(mib
->fddiSMTConfigPolicy
= word_val
) ;
1305 case SMT_P101B
: /* fddiSMTConnectionPolicy */
1306 if (!(word_val
& POLICY_MM
))
1308 IFSET(mib
->fddiSMTConnectionPolicy
= word_val
) ;
1310 case SMT_P101D
: /* fddiSMTTT_Notify */
1311 if (word_val
< 2 || word_val
> 30)
1313 IFSET(mib
->fddiSMTTT_Notify
= word_val
) ;
1315 case SMT_P101E
: /* fddiSMTStatRptPolicy */
1318 IFSET(mib
->fddiSMTStatRptPolicy
= byte_val
) ;
1320 case SMT_P101F
: /* fddiSMTTrace_MaxExpiration */
1322 * note: lower limit trace_max = 6.001773... s
1325 if (long_val
< (long)0x478bf51L
)
1327 IFSET(mib
->fddiSMTTrace_MaxExpiration
= long_val
) ;
1330 case SMT_P10F2
: /* fddiESSPayload */
1331 if (long_val
> 1562)
1333 if (set
&& smc
->mib
.fddiESSPayload
!= long_val
) {
1334 smc
->ess
.raf_act_timer_poll
= TRUE
;
1335 smc
->mib
.fddiESSPayload
= long_val
;
1338 case SMT_P10F3
: /* fddiESSOverhead */
1339 if (long_val
< 50 || long_val
> 5000)
1341 if (set
&& smc
->mib
.fddiESSPayload
&&
1342 smc
->mib
.fddiESSOverhead
!= long_val
) {
1343 smc
->ess
.raf_act_timer_poll
= TRUE
;
1344 smc
->mib
.fddiESSOverhead
= long_val
;
1347 case SMT_P10F4
: /* fddiESSMaxTNeg */
1348 if (long_val
> -MS2BCLK(5) || long_val
< -MS2BCLK(165))
1350 IFSET(mib
->fddiESSMaxTNeg
= long_val
) ;
1352 case SMT_P10F5
: /* fddiESSMinSegmentSize */
1353 if (long_val
< 1 || long_val
> 4478)
1355 IFSET(mib
->fddiESSMinSegmentSize
= long_val
) ;
1357 case SMT_P10F6
: /* fddiESSCategory */
1358 if ((long_val
& 0xffff) != 1)
1360 IFSET(mib
->fddiESSCategory
= long_val
) ;
1362 case SMT_P10F7
: /* fddiESSSyncTxMode */
1365 IFSET(mib
->fddiESSSynchTxMode
= word_val
) ;
1369 case SMT_P10F8
: /* fddiSBACommand */
1370 if (byte_val
!= SB_STOP
&& byte_val
!= SB_START
)
1372 IFSET(mib
->fddiSBACommand
= byte_val
) ;
1374 case SMT_P10F9
: /* fddiSBAAvailable */
1377 IFSET(mib
->fddiSBAAvailable
= byte_val
) ;
1380 case SMT_P2020
: /* fddiMACRequestedPaths */
1381 if ((word_val
& (MIB_P_PATH_PRIM_PREFER
|
1382 MIB_P_PATH_PRIM_ALTER
)) == 0 )
1384 IFSET(mib_m
->fddiMACRequestedPaths
= word_val
) ;
1386 case SMT_P205F
: /* fddiMACFrameErrorThreshold */
1387 /* 0 .. ffff acceptable */
1388 IFSET(mib_m
->fddiMACFrameErrorThreshold
= word_val
) ;
1390 case SMT_P2067
: /* fddiMACNotCopiedThreshold */
1391 /* 0 .. ffff acceptable */
1392 IFSET(mib_m
->fddiMACNotCopiedThreshold
= word_val
) ;
1394 case SMT_P2076
: /* fddiMACMA_UnitdataEnable */
1398 mib_m
->fddiMACMA_UnitdataEnable
= byte_val
;
1399 queue_event(smc
,EVENT_RMT
,RM_ENABLE_FLAG
) ;
1402 case SMT_P20F1
: /* fddiMACT_Min */
1403 IFSET(mib_m
->fddiMACT_Min
= long_val
) ;
1406 if (long_val
> 1562)
1408 IFSET(mib_a
->fddiPATHSbaPayload
= long_val
) ;
1411 ess_para_change(smc
) ;
1415 if (long_val
> 5000)
1418 if (long_val
!= 0 && mib_a
->fddiPATHSbaPayload
== 0)
1421 IFSET(mib_a
->fddiPATHSbaOverhead
= long_val
) ;
1424 ess_para_change(smc
) ;
1427 case SMT_P3213
: /* fddiPATHT_Rmode */
1429 * 0 .. 343.597 => 0 .. 2e32 * 80nS
1432 mib_a
->fddiPATHT_Rmode
= long_val
;
1433 rtm_set_timer(smc
) ;
1436 case SMT_P3214
: /* fddiPATHSbaAvailable */
1437 if (long_val
> 0x00BEBC20L
)
1440 if (set
&& mib
->fddiSBACommand
== SB_STOP
)
1443 IFSET(mib_a
->fddiPATHSbaAvailable
= long_val
) ;
1445 case SMT_P3215
: /* fddiPATHTVXLowerBound */
1446 IFSET(mib_a
->fddiPATHTVXLowerBound
= long_val
) ;
1447 goto change_mac_para
;
1448 case SMT_P3216
: /* fddiPATHT_MaxLowerBound */
1449 IFSET(mib_a
->fddiPATHT_MaxLowerBound
= long_val
) ;
1450 goto change_mac_para
;
1451 case SMT_P3217
: /* fddiPATHMaxT_Req */
1452 IFSET(mib_a
->fddiPATHMaxT_Req
= long_val
) ;
1455 if (set
&& smt_set_mac_opvalues(smc
)) {
1456 RS_SET(smc
,RS_EVENT
) ;
1457 smc
->sm
.please_reconnect
= 1 ;
1458 queue_event(smc
,EVENT_ECM
,EC_DISCONNECT
) ;
1461 case SMT_P400E
: /* fddiPORTConnectionPolicies */
1464 IFSET(mib_p
->fddiPORTConnectionPolicies
= byte_val
) ;
1466 case SMT_P4011
: /* fddiPORTRequestedPaths */
1467 /* all 3*8 bits allowed */
1468 IFSET(memcpy((char *)mib_p
->fddiPORTRequestedPaths
,
1469 (char *)&long_val
,4)) ;
1471 case SMT_P401F
: /* fddiPORTMaint_LS */
1474 IFSET(mib_p
->fddiPORTMaint_LS
= word_val
) ;
1476 case SMT_P403A
: /* fddiPORTLer_Cutoff */
1477 if (byte_val
< 4 || byte_val
> 15)
1479 IFSET(mib_p
->fddiPORTLer_Cutoff
= byte_val
) ;
1481 case SMT_P403B
: /* fddiPORTLer_Alarm */
1482 if (byte_val
< 4 || byte_val
> 15)
1484 IFSET(mib_p
->fddiPORTLer_Alarm
= byte_val
) ;
1490 case SMT_P103C
: /* fddiSMTStationAction */
1491 if (smt_action(smc
,SMT_STATION_ACTION
, (int) word_val
, 0))
1494 case SMT_P4046
: /* fddiPORTAction */
1495 if (smt_action(smc
,SMT_PORT_ACTION
, (int) word_val
,
1496 port_to_mib(smc
,port
)))
1505 /* parameter value in frame is out of range */
1506 return SMT_RDF_RANGE
;
1509 /* parameter value in frame is too short */
1510 return SMT_RDF_LENGTH
;
1514 /* parameter not setable, because the SBA is not active
1515 * Please note: we give the return code 'not authorizeed
1516 * because SBA denied is not a valid return code in the
1519 return SMT_RDF_AUTHOR
;
1523 static const struct s_p_tab
*smt_get_ptab(u_short para
)
1525 const struct s_p_tab
*pt
;
1526 for (pt
= p_tab
; pt
->p_num
&& pt
->p_num
!= para
; pt
++)
1528 return pt
->p_num
? pt
: NULL
;
1531 static int smt_mib_phys(struct s_smc
*smc
)
1538 if (smc
->s
.sas
== SMT_SAS
)
1544 static int port_to_mib(struct s_smc
*smc
, int p
)
1551 if (smc
->s
.sas
== SMT_SAS
)
1560 void dump_smt(struct s_smc
*smc
, struct smt_header
*sm
, char *text
)
1563 struct smt_para
*pa
;
1567 #ifdef LITTLE_ENDIAN
1574 if (smc
->debug
.d_smtf
< 2)
1576 if (debug
.d_smtf
< 2)
1579 #ifdef LITTLE_ENDIAN
1580 smtlen
= sm
->smt_len
+ sizeof(struct smt_header
) ;
1582 printf("SMT Frame [%s]:\nDA ",text
) ;
1583 dump_hex((char *) &sm
->smt_dest
,6) ;
1585 dump_hex((char *) &sm
->smt_source
,6) ;
1586 printf(" Class %x Type %x Version %x\n",
1587 sm
->smt_class
,sm
->smt_type
,sm
->smt_version
) ;
1588 printf("TID %lx\t\tSID ",sm
->smt_tid
) ;
1589 dump_hex((char *) &sm
->smt_sid
,8) ;
1590 printf(" LEN %x\n",sm
->smt_len
) ;
1593 pa
= (struct smt_para
*) (sm
+ 1) ;
1597 printf("TYPE %x LEN %x VALUE\t",pa
->p_type
,pa
->p_len
) ;
1599 printf("TYPE %04x LEN %2x VALUE\t",pa
->p_type
,pa
->p_len
) ;
1602 if ( (n
< 0 ) || (n
> (int)(len
- PARA_LEN
))) {
1603 n
= len
- PARA_LEN
;
1604 printf(" BAD LENGTH\n") ;
1607 #ifdef LITTLE_ENDIAN
1608 smt_swap_para(sm
,smtlen
,0) ;
1611 dump_hex((char *)(pa
+1),(int) n
) ;
1616 c
= (char *)(pa
+1) ;
1622 nn
= (n
> 16) ? 16 : n
;
1625 printf("\t\t\t...\n") ;
1637 #ifdef LITTLE_ENDIAN
1638 smt_swap_para(sm
,smtlen
,1) ;
1640 plen
= (pa
->p_len
+ PARA_LEN
+ 3) & ~3 ;
1642 pa
= (struct smt_para
*)((char *)pa
+ plen
) ;
1644 printf("-------------------------------------------------\n\n") ;
1647 void dump_hex(char *p
, int len
)
1653 printf("%x%s",*p
++ & 0xff,len
? ( (n
& 7) ? " " : "-") : "") ;
1655 printf("%02x%s",*p
++ & 0xff,len
? ( (n
& 7) ? " " : "-") : "") ;
1659 #endif /* no BOOT */
1663 #endif /* no SLIM_SMT */