added test rules
diff --git a/scripts/test_rules/sdf_rules.py b/scripts/test_rules/sdf_rules.py
new file mode 100755
index 0000000..a76ac2e
--- /dev/null
+++ b/scripts/test_rules/sdf_rules.py
@@ -0,0 +1,170 @@
+#!/usr/bin/python
+#coding: utf8
+#Copyright © 2016 - 2017 Copyright (c) Sprint, Inc. and others. All rights
+#reserved.
+#
+#This program and the accompanying materials are made available under the
+#terms of the Eclipse Public License v1.0 which accompanies this distribution,
+#and is available at http://www.eclipse.org/legal/epl-v10.html
+#
+############################################################################
+# File : sdf_rules.py
+#
+# Comments :
+# Read SDF Rules config file from './config/' and get parameters
+# values as per the SDF Rule Table.
+# As per SDF Rule table, formed a structure and parse values in structure,
+# and finally pack a structure and send over the zmq socket to DP.
+#
+# Reference : message_sdn_dp.docx
+# Section : Table No.14 SDF Rule
+############################################################################
+
+import sys
+import os
+import time
+import struct
+import socket
+
+from netaddr import IPAddress
+from configparser import ConfigParser
+
+parser = ConfigParser()
+
+def parse_sdf_values(pub_socket,topicId):
+ # TBD: Need to handle exception
+ parser.read('./config/sdf_rules.cfg')
+ print "\n ---> Reading Values from SDF rules file <--- "
+ print "\n ---> Sending SDF Rules <---"
+
+ MSG_TYPE = 20
+ # Initilize the parameters
+ # Rule type set 0 if Rule String and 1 Five tuple
+ RULE_TYPE = 0
+ PCC_RULE_ID = 0
+ DIRECTION = 'bidirectional'
+ LOCAL_IP = '0.0.0.0'
+ LOCAL_IP_MASK = 0
+ IPV4_REMOTE = '0.0.0.0'
+ IPV4_REMOTE_MASK = 0
+ LOCAL_LOW_LIMIT_PORT = 0
+ LOCAL_HIGH_LIMIT_PORT = 65535
+ REMOTE_LOW_LIMIT_PORT = 0
+ REMOTE_HIGH_LIMIT_PORT = 65535
+ PRECEDENCE = 0
+ PROTOCOL = hex(0)
+ PROTOCOL_MASK = hex(0)
+
+ # Create the structure for SDF rule and parse the values in that.
+ for val in parser.sections():
+ if val != 'GLOBAL':
+ # TBD: Need to handle exception
+ PCC_RULE_ID += 1
+ if PCC_RULE_ID > 1:
+ PROTOCOL_MASK = '0xff'
+
+ if parser.has_option(val, 'RULE_TYPE'):
+ RULE_TYPE = int(parser.get(val, \
+ 'RULE_TYPE'))
+
+ if parser.has_option(val, 'RATING_GROUP'):
+ RATING_GROUP = int(parser.get(val, \
+ 'RATING_GROUP'))
+
+ if parser.has_option(val, 'DIRECTION'):
+ DIRECTION = str(parser.get(val, \
+ 'DIRECTION'))
+
+ if parser.has_option(val, 'PRECEDENCE'):
+ PRECEDENCE = int(parser.get(val, \
+ 'PRECEDENCE'))
+
+ if parser.has_option(val, 'LOCAL_IP'):
+ LOCAL_IP = str(parser.get(val, \
+ 'LOCAL_IP'))
+
+ if parser.has_option(val, 'LOCAL_IP_MASK'):
+ LOCAL_IP_MASK = str(parser.get(val, \
+ 'LOCAL_IP_MASK'))
+
+ if parser.has_option(val, 'IPV4_REMOTE'):
+ IPV4_REMOTE = str(parser.get(val, \
+ 'IPV4_REMOTE'))
+
+ if parser.has_option(val, 'IPV4_REMOTE_MASK'):
+ IPV4_REMOTE_MASK = \
+ IPAddress(struct.unpack('!L', \
+ socket.inet_aton(\
+ str(parser.get(val, \
+ 'IPV4_REMOTE_MASK'))))\
+ [0]).netmask_bits()
+
+ if parser.has_option(val, 'PROTOCOL'):
+ PROTOCOL = hex(int(parser.get(val, \
+ 'PROTOCOL')))
+
+ if parser.has_option(val, 'PROTOCOL_MASK'):
+ PROTOCOL_MASK = int(parser.get(val, \
+ 'PROTOCOL_MASK'))
+
+ if parser.has_option(val, 'LOCAL_LOW_LIMIT_PORT'):
+ LOCAL_LOW_LIMIT_PORT = int(parser.get(val, \
+ 'LOCAL_LOW_LIMIT_PORT'))
+
+ if parser.has_option(val, 'LOCAL_HIGH_LIMIT_PORT'):
+ LOCAL_HIGH_LIMIT_PORT = int(parser.get(val, \
+ 'LOCAL_HIGH_LIMIT_PORT'))
+
+ if parser.has_option(val, 'REMOTE_LOW_LIMIT_PORT'):
+ REMOTE_LOW_LIMIT_PORT = int(parser.get(val, \
+ 'REMOTE_LOW_LIMIT_PORT'))
+
+ if parser.has_option(val, 'REMOTE_HIGH_LIMIT_PORT'):
+ REMOTE_HIGH_LIMIT_PORT = int(parser.get(val, \
+ 'REMOTE_HIGH_LIMIT_PORT'))
+
+ if DIRECTION == 'bidirectional':
+ RULE_STRING = \
+ str("%s/%s %s/%s %s : %s %s : %s %s/%s") % \
+ (IPV4_REMOTE, IPV4_REMOTE_MASK, \
+ LOCAL_IP, LOCAL_IP_MASK, \
+ REMOTE_LOW_LIMIT_PORT, \
+ REMOTE_HIGH_LIMIT_PORT, \
+ LOCAL_LOW_LIMIT_PORT, \
+ LOCAL_HIGH_LIMIT_PORT, \
+ PROTOCOL, PROTOCOL_MASK)
+
+ elif DIRECTION == 'uplink_only':
+ RULE_STRING = \
+ str("%s/%s %s/%s %s : %s %s : %s %s/%s") % \
+ (LOCAL_IP, LOCAL_IP_MASK, \
+ IPV4_REMOTE, IPV4_REMOTE_MASK, \
+ LOCAL_LOW_LIMIT_PORT, \
+ LOCAL_HIGH_LIMIT_PORT, \
+ REMOTE_LOW_LIMIT_PORT, \
+ REMOTE_HIGH_LIMIT_PORT, \
+ PROTOCOL, PROTOCOL_MASK)
+
+ elif DIRECTION == 'downlink_only':
+ RULE_STRING = \
+ str("%s/%s %s/%s %s : %s %s : %s 0x%s/0x%s") % \
+ (IPV4_REMOTE, IPV4_REMOTE_MASK, \
+ LOCAL_IP, LOCAL_IP_MASK, \
+ REMOTE_LOW_LIMIT_PORT, \
+ REMOTE_HIGH_LIMIT_PORT, \
+ LOCAL_LOW_LIMIT_PORT, \
+ LOCAL_HIGH_LIMIT_PORT, \
+ PROTOCOL, PROTOCOL_MASK)
+
+ # TBD: Need to handle exception
+ # Pack the structure and send over the zmq socket to DP
+ pub_socket.send("%s" % (struct.pack('!BBLLBI'+\
+ str(len(RULE_STRING))+'s',topicId, MSG_TYPE,\
+ PCC_RULE_ID, PRECEDENCE, RULE_TYPE, \
+ len(RULE_STRING), RULE_STRING)))
+ time.sleep(1)
+ print "\nSDF Rule Values for %s :: \nPCC_RULE_ID :%s \
+ \nPRECEDENCE :%s \nRULE_TYPE :%s \nRULE_STRING :%s"\
+ % (val, PCC_RULE_ID, PRECEDENCE, RULE_TYPE, RULE_STRING)
+ print '\n ---># SDF Rule Successfully sent.. #<---\n'
+ parser.clear()