#!/usr/bin/env python
#
# Standard imports
#
import string
import struct, socket, select
import thread
import wx
import win32gui
import MySQLdb
import sys
from CATController import *
ID_VALUE=0
SERVER_HANDLE=None
ip=None
try:
from pysnmp.entity.rfc3413.oneliner import cmdgen
from pysnmp import asn1
import socket,pyasn1.error,md5,sha
from asyncore import socket_map
from pyasn1.codec.ber import decoder
from pysnmp.proto import rfc1902
except Exception,e:
print "Error:",e
import snmpset
import random
import traceback,os
# Default variables
#
TFTP_PORT = 69
TFTP_PORT_MVP = 16869 # For MediaMVP, if bootp runs on 16867
#
# TFTP Errors
#
class TFTPError(Exception):
pass
#
# A class for a TFTP Connection
#
class TFTPConnection:
RRQ = 1
WRQ = 2
DATA = 3
ACK = 4
ERR = 5
HDRSIZE = 4 # number of bytes for OPCODE and BLOCK in header
def __init__(self, port=0,
blocksize=512, timeout=2.0, retry=5 ):
self.port = port
self.blocksize = blocksize
self.timeout = timeout
self.retry = retry
self.client_addr = None
self.sock = None
self.active = 0
self.blockNumber = 0
self.lastpkt = ""
self.mode = ""
self.filename = ""
self.file = None
self.bind('', port)
global ValidIp
# end __init__
def bind(self, host="", port=0):
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.sock = sock
if host or port:
sock.bind((host, port))
# end start
def send(self, pkt=""):
self.sock.sendto(pkt, self.client_addr)
self.lastpkt = pkt
# end send
def recv(self):
sock = self.sock
F = sock.fileno()
client_addr = self.client_addr
timeout = self.timeout
retry = self.retry
while retry:
r,w,e = select.select( [F], [], [F], timeout)
if not r:
# We timed out -- retransmit
retry = retry - 1
self.retransmit()
else:
# Read data packet
pktsize = self.blocksize + self.HDRSIZE
data, addr = sock.recvfrom(pktsize)
if addr == client_addr:
break
else:
raise TFTPError(4, "Transfer timed out")
# end while
return self.parse(data)
# end recv
def parse(self, data, unpack=struct.unpack):
buf = buffer(data)
pkt = {}
opcode = pkt["opcode"] = unpack("!h", buf[:2])[0]
if ( opcode == self.RRQ ) or ( opcode == self.WRQ ):
filename, mode, junk = string.split(data[2:], "\000", 2)
pkt["filename"] = filename
pkt["mode"] = mode
while junk:
key, value, junk = junk.split("\000", 2)
if key == 'blksize':
self.blocksize = int(value)
elif key == 'timeout':
self.timeout = float(value)
pkt[key] = value
elif opcode == self.ACK:
block = pkt["block"] = unpack("!h", buf[2:4])[0]
elif opcode == self.DATA:
block = pkt["block"] = unpack("!h", buf[2:4])[0]
data = pkt["data"] = buf[4:]
elif opcode == self.ERR:
errnum = pkt["errnum"] = unpack("!h", buf[2:4])[0]
errtxt = pkt["errtxt"] = buf[4:-1]
else:
raise TFTPError(4, "Unknown packet type")
return pkt
# end recv
def retransmit(self):
self.sock.sendto(self.lastpkt, self.client_addr)
return
# end retransmit
def connect(self, addr, data):
self.client_addr = addr
RRQ = self.RRQ
WRQ = self.WRQ
DATA = self.DATA
ACK = self.ACK
ERR = self.ERR
global ip
print "Client:", addr
try:
pkt = self.parse(data)
opcode = pkt["opcode"]
if opcode not in (RRQ, WRQ):
raise TFTPError(4, "Bad request")
# Start lock-step transfer
self.active = 1
if opcode == RRQ:
self.handleRRQ(pkt)
else:
self.handleWRQ(pkt)
# Loop until done
while self.active:
pkt = self.recv()
opcode = pkt["opcode"]
if opcode == DATA:
self.recvData(pkt)
elif opcode == ACK:
self.recvAck(pkt)
elif opcode == ERR:
self.recvErr(pkt)
else:
raise TFTPError(5, "Invalid opcode")
except TFTPError, detail:
self.sendError( detail[0], detail[1] )
print "Config File Download Completes Successfully"
self.file.close()
Percentage=10/ValidIp
global ID_VALUE
ID_VALUE+=1
print "ID_VALUE1",ID_VALUE
IncValue=frame_1.IncPercentage(Percentage)
frame_1.SetLabel("Config File download,"+str(IncValue)+"% Completed")
frame_1.Increment(Percentage)
return
# end connection
def recvAck(self, pkt):
if pkt["block"] == self.blockNumber:
# We received the correct ACK
self.handleACK(pkt)
return
# end recvAck
def recvData(self, pkt):
if pkt["block"] == self.blockNumber:
# We received the correct DATA packet
self.active = ( self.blocksize == len(pkt["data"]) )
self.handleDATA(pkt)
return
# end recvError
def recvErr(self, pkt):
self.handleERR(pkt)
self.retransmit()
# end recvErr
def sendData(self, data, pack=struct.pack):
blocksize = self.blocksize
block = self.blockNumber = self.blockNumber + 1
lendata = len(data)
format = "!hh%ds" % lendata
pkt = pack(format, self.DATA, block, data)
self.send(pkt)
self.active = (len(data) == blocksize)
# end sendData
def sendAck(self, pack=struct.pack):
block = self.blockNumber
self.blockNumber = self.blockNumber + 1
format = "!hh"
pkt = pack(format, self.ACK, block)
self.send(pkt)
# end sendAck
def sendError(self, errnum, errtext, pack=struct.pack):
errtext = errtext + "\000"
format = "!hh%ds" % len(errtext)
outdata = pack(format, self.ERR, errnum, errtext)
self.sock.sendto(outdata, self.client_addr)
return
# end sendError
#
#
# Override these handle* methods as needed
#
#
def handleRRQ(self, pkt):
filename = pkt["filename"]
mode = pkt["mode"]
try:
self.file = self.readRequest(filename, mode)
except:
self.sendError(1, "Cannot open file")
print "Cannot open file for reading %s\n%s: %s" % ((filename,) + sys.exc_info()[:2])
return
self.sendData( self.file.read(self.blocksize) )
# end readFile
def handleWRQ(self, pkt):
filename = pkt["filename"]
mode = pkt["mode"]
try:
self.file = self.writeRequest(filename, mode)
except:
self.sendError(1, "Cannot open file")
print "Cannot open file for writing %s\n%s: %s" % ((filename,) +
