• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2 * Conditions Of Use
3 *
4 * This software was developed by employees of the National Institute of
5 * Standards and Technology (NIST), an agency of the Federal Government.
6 * Pursuant to title 15 Untied States Code Section 105, works of NIST
7 * employees are not subject to copyright protection in the United States
8 * and are considered to be in the public domain.  As a result, a formal
9 * license is not needed to use the software.
10 *
11 * This software is provided by NIST as a service and is expressly
12 * provided "AS IS."  NIST MAKES NO WARRANTY OF ANY KIND, EXPRESS, IMPLIED
13 * OR STATUTORY, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF
14 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT
15 * AND DATA ACCURACY.  NIST does not warrant or make any representations
16 * regarding the use of the software or the results thereof, including but
17 * not limited to the correctness, accuracy, reliability or usefulness of
18 * the software.
19 *
20 * Permission to use this software is contingent upon your acceptance
21 * of the terms of this agreement
22 *
23 * .
24 *
25 */
26 /**************************************************************************/
27 /* Product of NIST Advanced Networking Technologies Division  */
28 /**************************************************************************/
29 
30 package gov.nist.javax.sip.header;
31 import gov.nist.core.DuplicateNameValueList;
32 import gov.nist.core.NameValue;
33 import gov.nist.core.NameValueList;
34 import gov.nist.javax.sip.address.GenericURI;
35 
36 import java.io.Serializable;
37 import java.text.ParseException;
38 import java.util.Iterator;
39 
40 import javax.sip.header.Parameters;
41 
42 /**
43  * Parameters header. Suitable for extension by headers that have parameters.
44  *
45  * @author M. Ranganathan   <br/>
46  *
47  *
48  * @version 1.2 $Revision: 1.15 $ $Date: 2010/01/12 00:05:27 $
49  *
50  */
51 public abstract class ParametersHeader
52     extends SIPHeader
53     implements javax.sip.header.Parameters, Serializable {
54     protected NameValueList parameters;
55 
56     protected DuplicateNameValueList duplicates;
57 
ParametersHeader()58     protected ParametersHeader() {
59         this.parameters = new NameValueList();
60         this.duplicates = new DuplicateNameValueList();
61     }
62 
ParametersHeader(String hdrName)63     protected ParametersHeader(String hdrName) {
64         super(hdrName);
65         this.parameters = new NameValueList();
66         this.duplicates = new DuplicateNameValueList();
67     }
68 
ParametersHeader(String hdrName, boolean sync)69     protected ParametersHeader(String hdrName, boolean sync) {
70         super(hdrName);
71         this.parameters = new NameValueList(sync);
72         this.duplicates = new DuplicateNameValueList();
73     }
74 
75     /**
76      * Returns the value of the named parameter, or null if it is not set. A
77      * zero-length String indicates flag parameter.
78      *
79      * @param name name of parameter to retrieve
80      * @return the value of specified parameter
81      */
82 
getParameter(String name)83     public String getParameter(String name) {
84         return this.parameters.getParameter(name);
85 
86     }
87 
88     /**
89      * Return the parameter as an object (dont convert to string).
90      *
91      * @param name is the name of the parameter to get.
92      * @return the object associated with the name.
93      */
getParameterValue(String name)94     public Object getParameterValue(String name) {
95         return this.parameters.getValue(name);
96     }
97 
98     /**
99      * Returns an Iterator over the names (Strings) of all parameters present
100      * in this ParametersHeader.
101      *
102      * @return an Iterator over all the parameter names
103      */
104 
getParameterNames()105     public Iterator<String> getParameterNames() {
106         return parameters.getNames();
107     }
108 
109     /** Return true if you have a parameter and false otherwise.
110      *
111      *@return true if the parameters list is non-empty.
112      */
113 
hasParameters()114     public boolean hasParameters() {
115         return parameters != null && !parameters.isEmpty();
116     }
117 
118     /**
119     * Removes the specified parameter from Parameters of this ParametersHeader.
120     * This method returns silently if the parameter is not part of the
121     * ParametersHeader.
122     *
123     * @param name - a String specifying the parameter name
124     */
125 
removeParameter(String name)126     public void removeParameter(String name) {
127         this.parameters.delete(name);
128     }
129 
130     /**
131      * Sets the value of the specified parameter. If the parameter already had
132      *
133      * a value it will be overwritten. A zero-length String indicates flag
134      *
135      * parameter.
136      *
137      *
138      *
139      * @param name - a String specifying the parameter name
140      *
141      * @param value - a String specifying the parameter value
142      *
143      * @throws ParseException which signals that an error has been reached
144      *
145      * unexpectedly while parsing the parameter name or value.
146      *
147      */
setParameter(String name, String value)148     public void setParameter(String name, String value) throws ParseException {
149         NameValue nv = parameters.getNameValue(name);
150         if (nv != null) {
151             nv.setValueAsObject(value);
152         } else {
153             nv = new NameValue(name, value);
154             this.parameters.set(nv);
155         }
156     }
157 
158     /**
159      * Sets the value of the specified parameter. If the parameter already had
160      *
161      * a value it will be overwritten. A zero-length String indicates flag
162      *
163      * parameter.
164      *
165      *
166      *
167      * @param name - a String specifying the parameter name
168      *
169      * @param value - a String specifying the parameter value
170      *
171      * @throws ParseException which signals that an error has been reached
172      *
173      * unexpectedly while parsing the parameter name or value.
174      *
175      */
setQuotedParameter(String name, String value)176     public void setQuotedParameter(String name, String value)
177         throws ParseException {
178         NameValue nv = parameters.getNameValue(name);
179         if (nv != null) {
180             nv.setValueAsObject(value);
181             nv.setQuotedValue();
182         } else {
183             nv = new NameValue(name, value);
184             nv.setQuotedValue();
185             this.parameters.set(nv);
186         }
187     }
188 
189     /**
190      * Sets the value of the specified parameter. If the parameter already had
191      *
192      * a value it will be overwritten.
193      *
194      *
195      * @param name - a String specifying the parameter name
196      *
197      * @param value - an int specifying the parameter value
198      *
199      * @throws ParseException which signals that an error has been reached
200      *
201      * unexpectedly while parsing the parameter name or value.
202      *
203      */
setParameter(String name, int value)204     protected void setParameter(String name, int value) {
205         Integer val = Integer.valueOf(value);
206         this.parameters.set(name,val);
207 
208     }
209 
210     /**
211      * Sets the value of the specified parameter. If the parameter already had
212      *
213      * a value it will be overwritten.
214      *
215      *
216      * @param name - a String specifying the parameter name
217      *
218      * @param value - a boolean specifying the parameter value
219      *
220      * @throws ParseException which signals that an error has been reached
221      *
222      * unexpectedly while parsing the parameter name or value.
223      *
224      */
setParameter(String name, boolean value)225     protected void setParameter(String name, boolean value) {
226         Boolean val = Boolean.valueOf(value);
227         this.parameters.set(name,val);
228     }
229 
230     /**
231      * Sets the value of the specified parameter. If the parameter already had
232      *
233      * a value it will be overwritten.
234      *
235      * @param name - a String specifying the parameter name
236      *
237      * @param value - a boolean specifying the parameter value
238      *
239      * @throws ParseException which signals that an error has been reached
240      *
241      * unexpectedly while parsing the parameter name or value.
242      *
243      */
setParameter(String name, float value)244     protected void setParameter(String name, float value) {
245         Float val = Float.valueOf(value);
246         NameValue nv = parameters.getNameValue(name);
247         if (nv != null) {
248             nv.setValueAsObject(val);
249         } else {
250             nv = new NameValue(name, val);
251             this.parameters.set(nv);
252         }
253     }
254 
255     /**
256      * Sets the value of the specified parameter. If the parameter already had
257      *
258      * a value it will be overwritten. A zero-length String indicates flag
259      *
260      * parameter.
261      *
262      *
263      *
264      * @param name - a String specifying the parameter name
265      *
266      * @param value - a String specifying the parameter value
267      *
268      * @throws ParseException which signals that an error has been reached
269      *
270      * unexpectedly while parsing the parameter name or value.
271      *
272      */
setParameter(String name, Object value)273     protected void setParameter(String name, Object value) {
274         this.parameters.set(name,value);
275     }
276 
277     /**
278      * Return true if has a parameter.
279      *
280      * @param parameterName is the name of the parameter.
281      *
282      * @return true if the parameter exists and false if not.
283      */
hasParameter(String parameterName)284     public boolean hasParameter(String parameterName) {
285         return this.parameters.hasNameValue(parameterName);
286     }
287 
288     /**
289      *Remove all parameters.
290      */
removeParameters()291     public void removeParameters() {
292         this.parameters = new NameValueList();
293     }
294 
295     /**
296      * get the parameter list.
297      * @return parameter list
298      */
getParameters()299     public NameValueList getParameters() {
300         return parameters;
301     }
302 
303     /** Set the parameter given a name and value.
304      *
305      * @param nameValue - the name value of the parameter to set.
306      */
setParameter(NameValue nameValue)307     public void setParameter(NameValue nameValue) {
308         this.parameters.set(nameValue);
309     }
310 
311     /**
312      * Set the parameter list.
313      *
314      * @param parameters The name value list to set as the parameter list.
315      */
setParameters(NameValueList parameters)316     public void setParameters(NameValueList parameters) {
317         this.parameters = parameters;
318     }
319 
320     /**
321      * Get the parameter as an integer value.
322      *
323      * @param parameterName -- the parameter name to fetch.
324      *
325      * @return -1 if the parameter is not defined in the header.
326      */
getParameterAsInt(String parameterName)327     protected int getParameterAsInt(String parameterName) {
328         if (this.getParameterValue(parameterName) != null) {
329             try {
330                 if (this.getParameterValue(parameterName) instanceof String) {
331                     return Integer.parseInt(this.getParameter(parameterName));
332                 } else {
333                     return ((Integer) getParameterValue(parameterName))
334                         .intValue();
335                 }
336             } catch (NumberFormatException ex) {
337                 return -1;
338             }
339         } else
340             return -1;
341     }
342 
343     /** Get the parameter as an integer when it is entered as a hex.
344      *
345      *@param parameterName -- The parameter name to fetch.
346      *
347      *@return -1 if the parameter is not defined in the header.
348      */
getParameterAsHexInt(String parameterName)349     protected int getParameterAsHexInt(String parameterName) {
350         if (this.getParameterValue(parameterName) != null) {
351             try {
352                 if (this.getParameterValue(parameterName) instanceof String) {
353                     return Integer.parseInt(
354                         this.getParameter(parameterName),
355                         16);
356                 } else {
357                     return ((Integer) getParameterValue(parameterName))
358                         .intValue();
359                 }
360             } catch (NumberFormatException ex) {
361                 return -1;
362             }
363         } else
364             return -1;
365     }
366 
367     /** Get the parameter as a float value.
368      *
369      *@param parameterName -- the parameter name to fetch
370      *
371      *@return -1 if the parameter is not defined or the parameter as a float.
372      */
getParameterAsFloat(String parameterName)373     protected float getParameterAsFloat(String parameterName) {
374 
375         if (this.getParameterValue(parameterName) != null) {
376             try {
377                 if (this.getParameterValue(parameterName) instanceof String) {
378                     return Float.parseFloat(this.getParameter(parameterName));
379                 } else {
380                     return ((Float) getParameterValue(parameterName))
381                         .floatValue();
382                 }
383             } catch (NumberFormatException ex) {
384                 return -1;
385             }
386         } else
387             return -1;
388     }
389 
390     /**
391      * Get the parameter as a long value.
392      *
393      * @param parameterName -- the parameter name to fetch.
394      *
395      * @return -1 if the parameter is not defined or the parameter as a long.
396      */
getParameterAsLong(String parameterName)397     protected long getParameterAsLong(String parameterName) {
398         if (this.getParameterValue(parameterName) != null) {
399             try {
400                 if (this.getParameterValue(parameterName) instanceof String) {
401                     return Long.parseLong(this.getParameter(parameterName));
402                 } else {
403                     return ((Long) getParameterValue(parameterName))
404                         .longValue();
405                 }
406             } catch (NumberFormatException ex) {
407                 return -1;
408             }
409         } else
410             return -1;
411     }
412 
413     /**
414      * Get the parameter value as a URI.
415      *
416      * @param parameterName -- the parameter name
417      *
418      * @return value of the parameter as a URI or null if the parameter
419      *  not present.
420      */
getParameterAsURI(String parameterName)421     protected GenericURI getParameterAsURI(String parameterName) {
422         Object val = getParameterValue(parameterName);
423         if (val instanceof GenericURI)
424             return (GenericURI) val;
425         else {
426             try {
427                 return new GenericURI((String) val);
428             } catch (ParseException ex) {
429                 //catch ( URISyntaxException ex) {
430                 return null;
431             }
432         }
433     }
434 
435     /**
436      * Get the parameter value as a boolean.
437      *
438      * @param parameterName -- the parameter name
439      * @return boolean value of the parameter.
440      */
getParameterAsBoolean(String parameterName)441     protected boolean getParameterAsBoolean(String parameterName) {
442         Object val = getParameterValue(parameterName);
443         if (val == null) {
444             return false;
445         } else if (val instanceof Boolean) {
446             return ((Boolean) val).booleanValue();
447         } else if (val instanceof String) {
448             return Boolean.valueOf((String) val).booleanValue();
449         } else
450             return false;
451     }
452 
453     /**
454      * This is for the benifit of the TCK.
455      *
456      * @return the name value pair for the given parameter name.
457      */
getNameValue(String parameterName)458     public NameValue getNameValue(String parameterName) {
459         return parameters.getNameValue(parameterName);
460     }
461 
462 
clone()463     public Object clone() {
464         ParametersHeader retval = (ParametersHeader) super.clone();
465         if (this.parameters != null)
466             retval.parameters = (NameValueList) this.parameters.clone();
467         return retval;
468     }
469 
470     //-------------------------
471     /**
472      * Introduced specifically for the P-Charging-Function-Addresses Header and
473      * all other headers that may have multiple header parameters of the same name, but
474      * with multiple possible values.
475      *
476      * Example: P-Charging-Function-Addresses: ccf=[5555::b99:c88:d77:e66]; ccf=[5555::a55:b44:c33:d22];
477      *                                         ecf=[5555::1ff:2ee:3dd:4cc]; ecf=[5555::6aa:7bb:8cc:9dd]
478      * @param name of the parameter
479      * @param value of the parameter
480      */
setMultiParameter(String name, String value)481     public void setMultiParameter(String name, String value)
482     {
483     	NameValue nv = new NameValue();
484     	nv.setName(name);
485     	nv.setValue(value);
486     	duplicates.set(nv);
487     }
488 
489     /** Set the parameter given a name and value.
490     *
491     * @param nameValue - the name value of the parameter to set.
492     */
setMultiParameter(NameValue nameValue)493    public void setMultiParameter(NameValue nameValue) {
494        this.duplicates.set(nameValue);
495    }
496 
497     /**
498      * Returns the parameter name
499      * @param name
500      * @return
501      */
getMultiParameter(String name)502     public String getMultiParameter(String name) {
503         return this.duplicates.getParameter(name);
504 
505     }
506 
507 
getMultiParameters()508     public DuplicateNameValueList getMultiParameters() {
509         return duplicates;
510     }
511 
512 
513     /**
514      * Return the parameter as an object (dont convert to string).
515      *
516      * @param name is the name of the parameter to get.
517      * @return the object associated with the name.
518      */
getMultiParameterValue(String name)519     public Object getMultiParameterValue(String name) {
520         return this.duplicates.getValue(name);
521     }
522 
523     /**
524      * Returns an Iterator over the names (Strings) of all parameters present
525      * in this ParametersHeader.
526      *
527      * @return an Iterator over all the parameter names
528      */
529 
getMultiParameterNames()530     public Iterator<String> getMultiParameterNames() {
531         return duplicates.getNames();
532     }
533 
534     /** Return true if you have a parameter and false otherwise.
535      *
536      *@return true if the parameters list is non-empty.
537      */
538 
hasMultiParameters()539     public boolean hasMultiParameters() {
540         return duplicates != null && !duplicates.isEmpty();
541     }
542 
543     /**
544     * Removes the specified parameter from Parameters of this ParametersHeader.
545     * This method returns silently if the parameter is not part of the
546     * ParametersHeader.
547     *
548     * @param name - a String specifying the parameter name
549     */
550 
removeMultiParameter(String name)551     public void removeMultiParameter(String name) {
552         this.duplicates.delete(name);
553     }
554 
555     /**
556      * Return true if has a parameter.
557      *
558      * @param parameterName is the name of the parameter.
559      *
560      * @return true if the parameter exists and false if not.
561      */
hasMultiParameter(String parameterName)562     public boolean hasMultiParameter(String parameterName) {
563         return this.duplicates.hasNameValue(parameterName);
564     }
565 
566     /**
567      *Remove all parameters.
568      */
removeMultiParameters()569     public void removeMultiParameters() {
570         this.duplicates = new DuplicateNameValueList();
571     }
572 
573     //-------------------------------
574 
575     @SuppressWarnings("unchecked")
equalParameters( Parameters other )576     protected final boolean equalParameters( Parameters other ) {
577         if (this==other) return true;
578 
579         for ( Iterator i = this.getParameterNames(); i.hasNext();) {
580             String pname = (String) i.next();
581 
582             String p1 = this.getParameter( pname );
583             String p2 = other.getParameter( pname );
584 
585             // getting them based on this.getParameterNames. Note that p1 may be null
586             // if this is a name-only parameter like rport or lr.
587             if (p1 == null ^ p2 == null) return false;
588             else if (p1 != null && !p1.equalsIgnoreCase(p2) ) return false;
589         }
590 
591         // Also compare other's parameters; some duplicate testing here...
592         for ( Iterator i = other.getParameterNames(); i.hasNext();) {
593             String pname = (String) i.next();
594 
595             String p1 = other.getParameter( pname );
596             String p2 = this.getParameter( pname );
597 
598                 // assert( p1 != null );
599             // if ( p1 == null ) throw new RuntimeException("Assertion check failed!");
600             // if (p2==null) return false;
601 
602             // getting them based on this.getParameterNames. Note that p1 may be null
603             // if this is a name-only parameter like rport or lr.
604 
605             if (p1 == null ^ p2 == null) return false;
606             else if (p1 != null && !p1.equalsIgnoreCase(p2) ) return false;
607         }
608 
609         return true;
610     }
611 
612 
613     // ----------- Abstract methods --------------
encodeBody()614     protected abstract String encodeBody();
615 
616 }
617