def do_POST(self):
if self.path != '/connect':
self.finish_up(404)
return
form = FieldStorage(
fp=self.rfile,
headers=self.headers,
environ={'REQUEST_METHOD': 'POST',
'CONTENT_TYPE': self.headers['Content-Type']}
)
them = form.getvalue('them')
if them is None:
self.finish_up(500)
return
# only connect people we have not recently connected
# silently swallow requests for reconnections
status_code = 200
if them not in self.previous:
self.previous.append(them)
status_code = send_connection_message(them)
print("Emailed %s. MG code: %i", them, status_code)
else:
print("We recently emailed %s so skipping them.", them)
self.finish_up(status_code)
def test_attachment_methods():
d = M.Discussion(shortname='test', name='test')
t = M.Thread.new(discussion_id=d._id, subject='Test Thread')
p = t.post('This is a post')
p_att = p.attach('foo.text', StringIO('Hello, world!'),
discussion_id=d._id,
thread_id=t._id,
post_id=p._id)
t_att = p.attach('foo2.text', StringIO('Hello, thread!'),
discussion_id=d._id,
thread_id=t._id)
d_att = p.attach('foo3.text', StringIO('Hello, discussion!'),
discussion_id=d._id)
ThreadLocalORMSession.flush_all()
assert p_att.post == p
assert p_att.thread == t
assert p_att.discussion == d
for att in (p_att, t_att, d_att):
assert 'wiki/_discuss' in att.url()
assert 'attachment/' in att.url()
# Test notification in mail
t = M.Thread.new(discussion_id=d._id, subject='Test comment notification')
fs = FieldStorage()
fs.name = 'file_info'
fs.filename = 'fake.txt'
fs.type = 'text/plain'
fs.file = StringIO('this is the content of the fake file\n')
p = t.post(text=u'test message', forum=None, subject='', file_info=fs)
ThreadLocalORMSession.flush_all()
n = M.Notification.query.get(
subject=u'[test:wiki] Test comment notification')
assert '\nAttachment: fake.txt (37 Bytes; text/plain)' in n.text
def test_attachment_methods():
d = M.Discussion(shortname="test", name="test")
t = M.Thread.new(discussion_id=d._id, subject="Test Thread")
p = t.post("This is a post")
p_att = p.attach("foo.text", StringIO("Hello, world!"), discussion_id=d._id, thread_id=t._id, post_id=p._id)
t_att = p.attach("foo2.text", StringIO("Hello, thread!"), discussion_id=d._id, thread_id=t._id)
d_att = p.attach("foo3.text", StringIO("Hello, discussion!"), discussion_id=d._id)
ThreadLocalORMSession.flush_all()
assert p_att.post == p
assert p_att.thread == t
assert p_att.discussion == d
for att in (p_att, t_att, d_att):
assert "wiki/_discuss" in att.url()
assert "attachment/" in att.url()
# Test notification in mail
t = M.Thread.new(discussion_id=d._id, subject="Test comment notification")
fs = FieldStorage()
fs.name = "file_info"
fs.filename = "fake.txt"
fs.type = "text/plain"
fs.file = StringIO("this is the content of the fake file\n")
p = t.post(text=u"test message", forum=None, subject="", file_info=fs)
ThreadLocalORMSession.flush_all()
n = M.Notification.query.get(subject=u"[test:wiki] Test comment notification")
assert "\nAttachment: fake.txt (37 Bytes; text/plain)" in n.text
def __init__(self, session):
self.consumer = oauth.Consumer(key = OSMOAuth.CONSUMER_KEY, secret = OSMOAuth.SHARED_SECRET)
self.client = oauth.Client(self.consumer)
data = session.data
self.data = data
args = FieldStorage()
if args.list != None and args.has_key('reset'):
data['oauth_token'] = None
data['oauth_token_secret'] = None
if data.get('oauth_token') != None:
self.is_authorized = data['oauth_authorized'] == '1'
else:
self.request_token()
if not self.is_authorized:
token = self.request_access_token()
if not 'oauth_token' in token:
self.request_token()
else:
data['oauth_token'] = token['oauth_token']
data['oauth_token_secret'] = token['oauth_token_secret']
data['oauth_authorized'] = '1'
print session.cookie
self.access_with()
def test_binary_create(self):
from io import BytesIO
fs = FieldStorage()
fs.file = BytesIO(b'fake_content')
values = {'data':fs}
self.provider.create(File, values)
def test_export_with_attachments(self):
project = M.Project.query.get(shortname='test')
discussion = project.app_instance('discussion')
post = Forum.query.get(shortname='general').sorted_threads[0].first_post
test_file1 = FieldStorage()
test_file1.name = 'file_info'
test_file1.filename = 'test_file'
test_file1.file = StringIO('test file1\n')
post.add_attachment(test_file1)
ThreadLocalORMSession.flush_all()
f = tempfile.TemporaryFile()
temp_dir = tempfile.mkdtemp()
discussion.bulk_export(f, temp_dir, True)
f.seek(0)
discussion = json.loads(f.read())
forums = sorted(discussion['forums'], key=lambda x: x['name'])
threads = sorted(forums[0]['threads'], key=lambda x: x['subject'])
file_path = os.path.join(
'discussion',
str(post.discussion_id),
str(post.thread_id),
post.slug,
'test_file'
)
assert_equal(threads[0]['posts'][0]['attachments'][0]['path'], file_path)
os.path.exists(file_path)
def test_upload_release_with_spaces(self):
from papaye.models import Root, Package, Release, ReleaseFile
from papaye.views.simple import UploadView
# Create a fake test file
uploaded_file = io.BytesIO(b"content")
storage = FieldStorage()
storage.filename = "foo.tar.gz"
storage.file = uploaded_file
self.request.POST = {
"content": storage,
"some_metadata": "Fake Metadata",
"version": "1.0",
"name": "my package",
":action": "file_upload",
"md5_digest": "Fake MD5",
}
root = Root()
self.request.root = root
view = UploadView(root, self.request)
result = view()
self.assertIsInstance(result, Response)
self.assertEqual(result.status_int, 200)
self.assertTrue("my-package" in root)
self.assertIsInstance(root["my-package"], Package)
self.assertTrue(root["my-package"].releases.get("1.0", False))
self.assertIsInstance(root["my-package"]["1.0"], Release)
self.assertTrue(root["my-package"]["1.0"].release_files.get("foo.tar.gz", b""))
self.assertIsInstance(root["my-package"]["1.0"]["foo.tar.gz"], ReleaseFile)
self.assertEqual(root["my-package"]["1.0"]["foo.tar.gz"].md5_digest, "Fake MD5")
self.assertIsNotNone(root["my-package"]["1.0"].metadata)
self.assertIsInstance(root["my-package"]["1.0"].metadata, dict)
self.assertEqual(root["my-package"]["1.0"].release_files.get("foo.tar.gz", b"").size, 7)
def test_upload_release_already_exists(self):
from papaye.models import Root, Package, Release, ReleaseFile
from papaye.views.simple import UploadView
# Create a fake test file
uploaded_file = io.BytesIO(b"content")
storage = FieldStorage()
storage.filename = "foo.tar.gz"
storage.file = uploaded_file
self.request.POST = {
"content": storage,
"some_metadata": "Fake Metadata",
"version": "1.0",
"name": "my_package",
":action": "file_upload",
}
root = Root()
# Create initial release
package = Package("my_package")
package["1.0"] = Release("1.0", "1.0", metadata={})
package["1.0"]["foo.tar.gz"] = ReleaseFile("foo.tar.gz", b"")
root["my-package"] = package
view = UploadView(root, self.request)
result = view()
self.assertIsInstance(result, Response)
self.assertEqual(result.status_int, 409)
def test_ms_data_as_file(self):
import tempfile
from cgi import FieldStorage
msfile = tempfile.TemporaryFile()
msfile.write('foo')
msfile.flush()
msfield = FieldStorage()
msfield.file = msfile
params = {'ms_data_format': 'mzxml',
'ms_data_file': msfield,
'max_ms_level': 3,
'abs_peak_cutoff': 1000,
'precursor_mz_precision': 0.005,
'mz_precision': 5.0,
'mz_precision_abs': 0.001,
'ionisation_mode': 1,
}
query = self.jobquery.add_ms_data(params)
script = "{magma} read_ms_data --ms_data_format 'mzxml'"
script += " -i '1' -m '3' -a '1000.0'"
script += " -p '5.0' -q '0.001' --precursor_mz_precision '0.005'"
script += " --call_back_url '/' ms_data.dat {db}\n"
expected_query = JobQuery(directory=self.jobdir,
prestaged=['ms_data.dat'],
script=script,
status_callback_url='/',
)
self.assertEqual(query, expected_query)
self.assertMultiLineEqual('foo', self.fetch_file('ms_data.dat'))
def test_export_with_attachments(self):
project = M.Project.query.get(shortname='test')
blog = project.app_instance('blog')
with h.push_context('test', 'blog', neighborhood='Projects'):
post = BM.BlogPost.new(
title='Test title',
text='test post',
labels=['the firstlabel', 'the second label'],
delete=None
)
ThreadLocalORMSession.flush_all()
test_file1 = FieldStorage()
test_file1.name = 'file_info'
test_file1.filename = 'test_file'
test_file1.file = StringIO('test file1\n')
p = post.discussion_thread.add_post(text='test comment')
p.add_multiple_attachments(test_file1)
ThreadLocalORMSession.flush_all()
f = tempfile.TemporaryFile()
temp_dir = tempfile.mkdtemp()
blog.bulk_export(f, temp_dir, True)
f.seek(0)
blog = json.loads(f.read())
blog['posts'] = sorted(
blog['posts'], key=lambda x: x['title'], reverse=True)
file_path = 'blog/{}/{}/{}/test_file'.format(
post._id,
post.discussion_thread._id,
list(post.discussion_thread.post_class().query.find())[0].slug
)
assert_equal(blog['posts'][0]['discussion_thread']['posts'][0]
['attachments'][0]['path'], file_path)
assert os.path.exists(os.path.join(temp_dir, file_path))
def test(self):
field = FieldStorage()
field.filename = 'aaa'
field.file = StringIO('abc')
field = WebpyFileField(field)
self.assertEqual('aaa', field.filename)
self.assertEqual(['abc'], list(field.chunks()))
def application(environ, start_response):
start_response('200 OK', [('Content-type', 'text/html')])
form = FieldStorage(fp=environ['wsgi.input'], environ=environ)
input = form.getvalue('eingabe')
auswahl = form.getvalue('auswahl')
if input:
filter= re.match('[0-9]+', input)
if filter:
eingabe = int(filter.group())
else:
eingabe= 0
if auswahl == 'Rekursiv':
try:
ausgabe = fibboRecursive(eingabe)
except:
ausgabe = 0
eingabe = 'Zahl zu gross'
else:
try:
ausgabe = fibboBinet(eingabe)
except:
ausgabe = 0
eingabe = 'Zahl zu gross'
else:
eingabe = ausgabe = ''
return [html_template % (eingabe, ausgabe)]
def repo_application(environ, start_response):
"""
The repositories WSGI application. If the incoming request's type is POST then it
will be delegated to a protocol handler, otherwise the default template will be returned.
"""
response_body = []
response_headers = []
status = '200 OK'
if environ['REQUEST_METHOD'] == 'POST':
try:
size = int(environ.get('CONTENT_LENGTH', 0))
except ValueError, e:
size = 0
args = FieldStorage(fp=environ['wsgi.input'], environ=environ)
jsonstr = args.getvalue('j')
logger.info('POST from %s: %s' % (environ['REMOTE_ADDR'], jsonstr))
try:
repository = Repository()
handler = ProtocolHandler(repository, jsonstr)
response_body = [handler.execute(environ)]
except DatabaseException, e:
logger.warning('database exception: %s' % str(e))
response_body = ['{"error":{"c":%d,"args":["errorstr":"%s"]}}' %
(RepositoryErrorCode.DATABASE_ERROR, str(e))]
def StoredHandler(environ, start_response):
from cgi import FieldStorage
import cgitb; cgitb.enable(display=0, logdir="/tmp")
form = FieldStorage(fp=environ['wsgi.input'], environ=environ)
print(form.keys())
start_response('200 Ok', [('Content-type', 'text/javascript')])
if "oper" not in form:
#print("Bad Request")
return [json.dumps([False, 'Bad Request'])]
method = environ['REQUEST_METHOD'].upper()
if method == 'GET' or method == 'HEAD':
return [json.dumps([False, 'bad request'])]
oper = form['oper']
print(oper)
section = form.getfirst('roof', 'imsto')
# section = form['section'] if form.has_key('section') else 'imsto'
imsto = load_imsto(section)
if oper.value == 'delete':
id = form['id']
r = imsto.delete(id.value)
print r
return [json.dumps(r)]
if oper.value == 'add':
if "new_file" not in form:
return [json.dumps([False, 'please select a file'])]
new_file = form['new_file']
if new_file is None:
return [json.dumps([False, 'invalid upload field'])]
# print(type(new_file))
result = []
if type(new_file) == type([]):
for f in new_file:
print('%r %r %r %r %r %r' % (f.name, f.filename, f.type, f.disposition, f.file, f.length))
r = imsto.store(f.file, ctype=f.type, name=f.filename)
print 'store: %r, result %r' % (f.name, r)
if type(r) == type([]):
result.append(r)
else:
result.append(False)
else:
f = new_file
print('single file %r %r' % (f.name, f.filename))
try:
result = imsto.store(f.file, ctype=f.type, name=f.filename)
print 'store: %r, result %r' % (f.name, result)
except Exception, e:
result = [False, e.message]
print "\n".join(get_traceback()) + "\n"
if hasattr(imsto, 'close'):
imsto.close()
return [json.dumps(result)]
def test_without_metabolize(self):
self.maxDiff = 100000
import tempfile
from cgi import FieldStorage
ms_data_file = tempfile.NamedTemporaryFile()
ms_data_file.write('foo')
ms_data_file.flush()
msfield = FieldStorage()
msfield.file = ms_data_file
params = MultiDict(ionisation_mode=1,
ms_intensity_cutoff=200000,
msms_intensity_cutoff=10,
abs_peak_cutoff=1000,
precursor_mz_precision=0.005,
max_broken_bonds=4,
max_water_losses=1,
mz_precision=5.0,
mz_precision_abs=0.001,
scenario=[{'type': 'phase1', 'steps': '2'},
{'type': 'phase2', 'steps': '1'}],
max_ms_level=3,
structures='C1CCCC1 comp1',
ms_data_file=msfield,
structure_format='smiles',
ms_data_format='mzxml',
structure_database='',
min_refscore=1,
max_mz=9999,
)
query = self.jobquery.allinone(params)
expected_script = "{magma} read_ms_data --ms_data_format 'mzxml'"
expected_script += " -i '1' -m '3' -a '1000.0'"
expected_script += " -p '5.0' -q '0.001'"
expected_script += " --precursor_mz_precision '0.005'"
expected_script += " --call_back_url '/'"
expected_script += " ms_data.dat {db}\n"
expected_script += "{magma} add_structures -g -t 'smiles'"
expected_script += " structures.dat {db}\n"
expected_script += "{magma} annotate -c '200000.0'"
expected_script += " -d '10.0'"
expected_script += " -b '4'"
expected_script += " --max_water_losses '1' --ncpus '1' --call_back_url '/'"
expected_script += " --fast {db}\n"
expected_query = JobQuery(directory=self.jobdir,
prestaged=['ms_data.dat', 'structures.dat'],
script=expected_script,
status_callback_url='/',
)
self.assertEqual(query, expected_query)
self.assertMultiLineEqual(params['structures'],
self.fetch_file('structures.dat'))
self.assertMultiLineEqual('foo', self.fetch_file('ms_data.dat'))
def test_binary_update(self):
fs = FieldStorage()
fs.file = BytesIO(b'fake_content')
values = {'data':fs}
entity = self.provider.create(File, values)
values = {'data':fs, 'file_id':entity.file_id}
self.provider.update(File, values)
def test_accept_multipart_content(self, result_request, tool_definition):
field_storage = FieldStorage()
field_storage.filename = 'x.txt'
field_storage.file = StringIO('whee')
tool_definition['argument_names'] = ('x_path',)
raw_arguments = {'x': field_storage}
result = result_request.prepare_arguments(
tool_definition, raw_arguments)
assert open(result.arguments['x_path']).read() == 'whee'
def main():
args = parse_qs(environ['QUERY_STRING'])
form = FormPost()
if form.has_key('FLUSH'):
flush_all()
if 'update' in args:
stat()
return
ats = ['items', 'bytes', 'oldest_item_age', 'hits', 'byte_hits', 'misses']
samples = mget('sample-times', namespace=NS)
if not samples:
stat()
samples = mget('sample-times', namespace=NS) or []
s = mmget([str(i) for i in samples], namespace=NS)
a = []
if s:
a = dict([(k, [int(s[d][k]) for d in s]) for k in ats]) # attr -> vals
a = dict([(k, (max(a[k]), min(a[k]), a[k])) for k in a]) # attrs -> (max, min, vals)
#a = dict([(k, [61*(v+1-a[k][1])/(a[k][0]+1-a[k][1]) for v in a[k][2]]) for k in a]) # attrs -> norml-vals
a = dict([(k, ([61*(v+1-a[k][1])/(a[k][0]+1-a[k][1]) for v in a[k][2]], a[k][1], a[k][0])) for k in a]) # attrs -> norml-vals
print "Content-type: text/html"
print ""
#l = ["rend('"+k+"', %s);"%str([int(s[d][k]) for d in s]) for k in ats]
#l = ["rend('"+k+"', %s);"%str([int(d) for d in a[k]]) for k in a]
print """<html><head><script type="text/javascript" src="http://www.solutoire.com/download/gchart/gchart-0.2alpha_uncompressed.js"></script>
<script>
// Using: http://solutoire.com/gchart/
// x = """+repr(a)+"""
function rend(t, d, mx, mn) {
GChart.render({'renderTo': 'stats', 'size': '800x200', colors: 'FF0000,00FF00,0000FF,FFFF00,00FFFF,FF00FF', legend:'"""+'|'.join([k for k in a])+"""', title: t, 'data': d});
}
function main() {
"""
def rnd(name, data, mxmn, colors, legend):
print "GChart.render({'size': '480x200&chg=0,20', axistype: 'x,y,r'," # colors: 'FF0000,00FF00,0000FF,FFFF00,00FFFF,FF00FF',"
print " renderTo: '"+name+"',"
if len(data) == 2:
print " axisrange: '1,"+','.join([str(i) for i in mxmn[0]])+"|2,"+','.join([str(i) for i in mxmn[1]])+"',"
elif len(data) == 1:
print " axisrange: '1,"+','.join([str(i) for i in mxmn[0]])+"', axistype: 'x,y',"
print " colors: '"+','.join(colors)+"',"
print " legend:'"+'|'.join([l for l in legend])+"',"
print " data: "+str([[int(d) for d in dd] for dd in data])
print "});"
#print "rend('stats', %s);"%str([[int(d) for d in a[k][0]] for k in a])
if a:
rnd('stats', [a['hits'][0], a['byte_hits'][0]], [a['hits'][1:3], a['byte_hits'][1:3]], ['FF0088', '0077cc'], ["Hits", "Hit Bytes"])
rnd('stats', [a['items'][0], a['bytes'][0]], [a['items'][1:3], a['bytes'][1:3]], ['FF0088', '0077cc'], ["Items", "Bytes"])
rnd('stats', [a['misses'][0]], [a['misses'][1:3]], ['FF0088'], ["Miss"])
rnd('stats', [a['oldest_item_age'][0]], [[x/60 for x in a['oldest_item_age'][1:3]]], ['0077cc'], ["Max Age"])
print """
def to_fieldstorage(f):
fs = FieldStorage()
fs.file = f
fs.type = f.mimetype
opt = f.mimetype_params
opt['filename'] = f.filename
fs.disposition_options = opt
fs.type_options = opt
return fs
def test_valid_imagefile_upload(self):
from adhocracy.forms.common import ValidImageFileUpload
from formencode import Invalid
from cgi import FieldStorage
from io import BytesIO
value = FieldStorage()
value.file = BytesIO(b"binarydata")
value.filename = u"test.png"
value.name = u"thumbs"
self.assertRaises(Invalid, ValidImageFileUpload.to_python, value)
def reply():
from cgi import FieldStorage
kwargs = FieldStorage()
if kwargs.has_key('addr') or kwargs.has_key('elseaddr'):
return whereyoulive_sum.reply(kwargs)
else:
return survey()
def upload_request(self, files: dict, metadata=None, user=None):
if metadata is None:
metadata = '{}'
fields = MultiDict({'metadata': metadata})
for name, content in files.items():
fs = FieldStorage()
fs.file = BytesIO(content)
fs.filename = name
fields.add('file', fs)
return self.generic_request(post=fields, user=user)
def web_loader(environ, start_response):
headers = [('Content-type', 'application/json; charset=UTF-8'), ("Access-Control-Allow-Origin", "*")]
start_response('200 OK', headers)
form = FieldStorage()
pid = os.fork()
if pid == 0: # new process
os.system("philoload4 %s %s &" % (form.getvalue("dbname"), form.getvalue("files")))
exit()
yield dumps({"success": True})
def import_stage(self, harvest_object):
package_dict = json.loads(harvest_object.content)
if not self._should_import_local(package_dict):
package_dict['state'] = 'deleted'
else:
package_dict = self._apply_package_extras_white_list(package_dict)
package_dict = self._apply_package_resource_extras_black_list(package_dict)
package_dict = self._fix_date_in_fields(package_dict)
package_dict = self._set_license(package_dict)
package_dict = self._pop_black_list_resources_by_type(package_dict)
harvest_object.content = json.dumps(package_dict)
upload_resources = self._pop_upload_resources(package_dict)
import_stage_result = super(GuiaHarvesterPlugin, self).import_stage(harvest_object)
if import_stage_result:
package_dict = json.loads(harvest_object.content)
harvested_rels = package_dict.get('relationships', [])
try:
this_package = model.Package.get(package_dict['name'])
if not this_package: raise logic.NotFound()
except logic.NotFound as nf:
log.info('import_stage(): could not find package "{0}"; relationships not updated: {1}'.format(package_dict['name'], nf))
return import_stage_result
existing_rels = this_package.get_relationships()
self._update_relationships(existing_rels, harvested_rels)
for resource_dict in upload_resources:
resource_url = resource_dict['url']
resource_filename = resource_url.split('/')[-1]
try:
response = requests.get(resource_url)
resource_file = StringIO(response.content)
except Exception,e:
self._save_object_error('Resource not harvested for package "{0}". Unable to fetch resource from "{1}": {2}'.format(package_dict['name'], resource_url, e), harvest_object, 'Import')
continue
cfs = FieldStorage()
cfs.file = resource_file
cfs.filename = resource_filename
resource_dict['upload'] = cfs
if 'created' in resource_dict: del resource_dict['created']
if 'last_modified' in resource_dict: del resource_dict['last_modified']
if 'api' in resource_dict: del resource_dict['api']
try:
the_resource = toolkit.get_action('resource_create')(data_dict=resource_dict)
except Exception,e:
self._save_object_error('Resource not harvested for package "{0}". Unable to import the resource originally from "{1}": {2}'.format(package_dict['name'], resource_url, e), harvest_object, 'Import')
continue
def GetQuery(QueryString, BlankIfMissing =0 ):
if not InGlobals("FormFieldStorage"):
from cgi import FieldStorage
global FormFieldStorage
FormFieldStorage = FieldStorage()
if FormFieldStorage.has_key(QueryString):
retVal = FormFieldStorage[QueryString].value
else:
retVal = iif(BlankIfMissing,"",None)
return retVal
def do_POST(self):
form = FieldStorage(
fp=self.rfile,
headers=self.headers,
environ={'REQUEST_METHOD':'POST',
'CONTENT_TYPE':self.headers['Content-Type'],
})
self.post = {}
for name in form.keys():
self.post[name] = form[name].value
return self.do_GET()
def test_create(self):
view = self.get_view()
content = FieldStorage()
content.file = pkg_resources.resource_stream(
'velo',
'static/img/trollface.png'
)
view.request.POST.update({
'longitude': 12.3,
'latitude': -45.4,
'content': content,
})
view.create()
def print_env(environ, start_response):
"""list environ items"""
import os
print(os.environ)
from cgi import FieldStorage
form = FieldStorage(environ=environ)
#print(form.keys())
for k in form.keys():
print ('k: %s' % k)
f = form[k]
print (f)
start_response('200 OK', [('Content-Type', 'text/plain')])
return ['\n'.join(['%s: %r' % item for item in environ.items()])]
def main():
# parse query string
arguments = FieldStorage(keep_blank_values=True)
json = arguments.getvalue('payload')
content = loads(json)
if 'commits' in content:
repo = content['repository']['name']
if repo in VALID_UPDATE_REPOSITORIES:
handle_repository_update(repo)
process_commit_mails(content)
def parse_body(self):
content_type, _ = self.content_type
if content_type == 'application/json':
self._body = json.loads(self.get_raw_body())
elif content_type == 'application/x-www-form-urlencoded':
self._body = dict(parse.parse_qsl(self.get_raw_body()))
elif content_type == 'multipart/form-data':
fs = FieldStorage(self.environ['wsgi.input'], environ=self.environ)
self._body, self._uploads = {}, {}
for name in fs.keys():
if fs[name].filename is None:
self._body[name] = fs[name].value
else:
self._uploads[name] = fs[name]
def render(self, request):
if self.server != "":
request.responseHeaders.removeHeader("Server")
request.responseHeaders.addRawHeader("Server", self.server)
if request.method == "GET":
_q_s.logs.info([
"servers", {
'server': 'http_server',
'action': 'get',
'ip': request.getClientIP()
}
])
if request.uri == "/login.html":
if _q_s.username != '' and _q_s.password != '':
request.responseHeaders.addRawHeader(
"Content-Type", "text/html; charset=utf-8")
return self.login_file
request.responseHeaders.addRawHeader(
"Content-Type", "text/html; charset=utf-8")
return self.home_file
elif request.method == "POST":
self.headers = request.getAllHeaders()
_q_s.logs.info([
"servers", {
'server': 'http_server',
'action': 'post',
'ip': request.getClientIP()
}
])
if _q_s.username != '' and _q_s.password != '':
form = FieldStorage(fp=request.content,
headers=self.headers,
environ={
'REQUEST_METHOD':
'POST',
'CONTENT_TYPE':
self.headers['content-type'],
})
if 'username' in form and 'password' in form:
if form['username'].value == _q_s.username and form[
'password'].value == _q_s.password:
_q_s.logs.info([
"servers", {
'server': 'http_server',
'action': 'login',
'status': 'success',
'ip': request.getClientIP(),
'username': _q_s.username,
'password': _q_s.password
}
])
else:
_q_s.logs.info([
"servers", {
'server': 'http_server',
'action': 'login',
'status': 'failed',
'ip': request.getClientIP(),
'username': form['username'].value,
'password': form['password'].value
}
])
request.responseHeaders.addRawHeader(
"Content-Type", "text/html; charset=utf-8")
return self.home_file
else:
request.responseHeaders.addRawHeader(
"Content-Type", "text/html; charset=utf-8")
return self.home_file
def __init__(self, *args, **kw): self._ok_max_files_count=-1 FieldStorage.__init__(self, *args, **kw)
def containsNum(s):
return any(char.isdigit() for char in s)
#from cgitb import enable
#enable()
from cgi import FieldStorage, escape
from hashlib import sha256
from time import time
from shelve import open
from http.cookies import SimpleCookie
import pymysql as db
redirBool = False
form_data = FieldStorage()
username = ''
result = ''
if len(form_data) != 0:
username = escape(form_data.getfirst('username', '').strip())
password = escape(form_data.getfirst('password', '').strip())
passwordConf = escape(form_data.getfirst('passwordConf', '').strip())
if not username or not password or not passwordConf:
result = '<p class=pwInf>Please fill the required fields</p>'
elif password.islower() or password.isupper() or not containsNum(password):
result = '<p class=pwInf>Your password is invalid. Passwords must contain a mixture of lowercase letters, uppercase letters and numbers.</p>'
elif password != passwordConf:
result = '<p class=pwInf>Please enter matching passwords</p>'
else:
try:
connection = db.connect('localhost', 'doh2', 'eipuohag',
from cgitb import enable
enable()
from os import environ
from shelve import open
from http.cookies import SimpleCookie
import pymysql as db
from cgi import FieldStorage,escape
from datetime import datetime
cookie=SimpleCookie()
http_cookie_header=environ.get('HTTP_COOKIE')
curdate= (str(datetime.now()).split('.'))[0]
message=''
form_data= FieldStorage()
forum=escape(form_data.getfirst('forum',''))
post=escape(form_data.getfirst('post',''))
logedin=False
logedin=False
if http_cookie_header:
cookie.load(http_cookie_header)
if 'sid' in cookie:
sessionId = cookie['sid'].value
sessionStore = open('../session_stores/session-' + sessionId, writeback=False)
if sessionStore.get('authenticated'):
logedin =True
if logedin==True:
logout="<form action='logout.py'><input type='submit' value='Log Out'></form>"
#!/usr/local/bin/python3
from cgi import FieldStorage
from html import escape
from cgitb import enable
enable()
print('Content-Type: text/html')
print()
form_data = FieldStorage()
length = escape(form_data.getfirst('length', '')).strip()
units = escape(form_data.getfirst('units', '')).strip()
output = ''
inches = 0.0
yards = 0.0
feet = 0.0
if units in ['feet', 'inches', 'yards']:
try:
if units == 'feet':
feet = float(length)
inches = feet * 12
yards = feet / 3
elif units == 'inches':
inches = float(length)
feet = inches / 12
yards = inches / 36
else:
yards = float(length)
print("Content-Type: text/html")
print()
def dict_rows(cur):
return [{k: v for k, v in zip(cur.description, row)} for row in cur]
def dict_row(cur):
return {k[0]: v for k, v in zip(cur.description, cur.fetchone())}
form, node_type, x, y, pathway = None, None, None, None, None
try:
form = FieldStorage()
node_type = form.getvalue('type')
x = form.getvalue('x')
y = form.getvalue('y')
pathway = form.getvalue("pathway")
except:
print(-1)
exit()
if type(x) is not str or type(y) is not str or type(
pathway) is not str or node_type not in [
"pathway", "protein", "metabolite", "label", "membrane", "image",
"invisible"
]:
print(-2)
from os import environ
from http.cookies import SimpleCookie
from cgi import FieldStorage, escape
from Player import *
from GameController import *
from getGameController import *
print("Content-Type:text/html")
print()
#Takes the Name, Colour and Avatar values sent from the previous page
#and assigns them to variables
name = ""
avatar = ""
colour = ""
form_data = FieldStorage()
if len(form_data) != 0:
name = escape(form_data.getfirst("name","").strip())
avatar = escape(form_data.getfirst("avatar", "").strip())
colour = escape(form_data.getfirst("colour","").strip())
#note for when using the game controller setGameController must
#be called at the end with the game controller in the parameter
#gets the users cookie from their browsers
cookie = SimpleCookie()
http_cookie_header = environ.get('HTTP_COOKIE')
#if there's no cookie return an error
if not http_cookie_header:
print("Error! Cookie header")
exit()
def vars(self):
return FieldStorage()
def application(environ, start_response):
output = ''
content_type = "text/html"
prefix = 'http://grey.colorado.edu:8080'
finished = False
form = FieldStorage(fp=environ['wsgi.input'], environ=environ)
query = form.getfirst('q')
url = form.getfirst('url')
proxy = form.getfirst('proxy')
# A query is a search, for example, for "void Blah::Blerg"
if query is not None and url is None:
"""
First we will try with +"query"
"""
try:
# Try the full signature, e.g., void BaseSpec::UpdateSubSpecs
url = prefix + '/source/search?q=' + quote_plus('+"' + query + '"')
soup = BeautifulSoup(urlopen(url).read())
url = soup.find('tt', {'class': 'con'}).a['href']
if '#' in url:
output = redirect(url)
else:
soup = BeautifulSoup(urlopen(prefix + url).read())
url = soup.find('a', {'class': 's'})['href']
output = redirect(url)
except:
try:
"""
Then we will try to find an exact match by searching for the query without quotes but
getting an exact string match
"""
url = prefix + '/source/search?q=' + quote_plus(query)
soup = BeautifulSoup(urlopen(url).read())
results = soup.findAll('tt', {'class': 'con'})
if results is not None:
for result in results:
if finished:
break
this_url = prefix + result.a['href']
this_soup = BeautifulSoup(urlopen(this_url).read())
possible_results = this_soup.findAll(
'a', {'class': 's'})
for this_result in possible_results:
this_sig = str(this_result).replace('<b>','').\
replace('</b>','').split('</span>')[1].split('</a>')[0].strip()
#print this_soup.findAll('a',{'class':'s'})[0]
#print query, '\t', this_sig
print this_sig
if query in this_sig:
output = redirect(this_result['href'])
finished = True
break
if not finished:
# hack to get it to try the next exception code
raise
except:
try:
"""
Now we will try within quotes but without the return type
"""
query = query.split(' ')[1]
url = prefix + '/source/search?q=' + quote_plus('+"' +
query +
'"')
soup = BeautifulSoup(urlopen(url).read())
url = soup.find('tt', {'class': 'con'}).a['href']
if '#' in url:
output = redirect(url)
else:
soup = BeautifulSoup(urlopen(prefix + url).read())
url = soup.find('a', {'class': 's'})['href']
output = redirect(url)
except:
try:
"""
Finally, just the method name
"""
query = query.split('::')[-1]
url = prefix + '/source/search?q=' + quote_plus('+"' +
query +
'"')
soup = BeautifulSoup(urlopen(url).read())
url = soup.find('tt', {'class': 'con'}).a['href']
if '#' in url:
print 'if guy'
output = redirect(url)
else:
soup = BeautifulSoup(urlopen(prefix + url).read())
url = soup.find('a', {'class': 's'})['href']
output = redirect(url)
except:
output = 'Sorry, I was unable to find the source code for this guy'
# This gets called recursively so we can take the user directly to the line
if url is not None and query is None:
output = intercept(url, prefix)
# Intercepting proxy mode
if proxy is not None and query is None and url is None:
url = proxy.replace('QUESTION_MARK', '?')
if '#' in url:
output = redirect(url)
else:
if 'png' in url:
content_type = "image/png"
elif 'css' in url:
content_type = "text/css"
if not 'source' in url:
url = '/source/' + url
output = intercept(url, prefix)
status = '200 OK'
response_headers = [('Content-type', content_type),
('Content-Length', str(len(output)))]
start_response(status, response_headers)
return [str(output)]
def test_multiple_attachments():
test_file1 = FieldStorage()
test_file1.name = 'file_info'
test_file1.filename = 'test1.txt'
test_file1.type = 'text/plain'
test_file1.file = StringIO('test file1\n')
test_file2 = FieldStorage()
test_file2.name = 'file_info'
test_file2.filename = 'test2.txt'
test_file2.type = 'text/plain'
test_file2.file = StringIO('test file2\n')
d = M.Discussion(shortname='test', name='test')
t = M.Thread.new(discussion_id=d._id, subject='Test Thread')
test_post = t.post('test post')
test_post.add_multiple_attachments([test_file1, test_file2])
ThreadLocalORMSession.flush_all()
assert_equals(len(test_post.attachments), 2)
attaches = test_post.attachments
assert 'test1.txt' in [attaches[0].filename, attaches[1].filename]
assert 'test2.txt' in [attaches[0].filename, attaches[1].filename]
#!/usr/local/bin/python3
from cgitb import enable
enable()
from cgi import FieldStorage, escape
import pymysql as db
username = ""
score = ""
print('Content-Type: text/plain')
print()
form_data = FieldStorage()
username = form_data.getfirst('username')
score = int(form_data.getfirst('score'))
try:
connection = db.connect('cs1dev.ucc.ie', 'ajbod1', 'eimaidae',
'users_ajbod1')
cursor = connection.cursor(db.cursors.DictCursor)
cursor.execute(
"""SELECT score
FROM breakoutstats
WHERE username=%s;""", (username))
old_score = cursor.fetchall()
print(old_score)
if int(old_score[0]['score']) < score:
cursor.execute(
<body>
<form action=”/cgi-bin/uploadfile.py” method=”POST”
enctype=”multipart/form-data”>
<input type=”file” name=”file_name” size=”50”>
<input type=”submit”>
</form>
</body>
</html>”””
shtml = ‘’’<HTML><HEAD><TITLE>
</TITLE></HEAD>
<BODY>
<H3>Contents: %s</H3>
<PRE>%s
</PRE>
</BODY></HTML>’’’
form=FieldStorage()
if not form:
print (header+dynhtml)
elif form.has_key(“file_name”):
fileupload=form[“file_name”]
data=’ ‘
if fileupload.file:
count=0
while 1:
line=fileupload.file.readline()
data=data+line
if not line:
break
count=count+1
print (header+shtml % (fileupload.filename,data))
else:
def _generate_resources_from_folder(self, dataset):
'''
Given a dataset folder, it'll return a list of resource metadata
'''
resources = []
file_list = [
f for f
in os.listdir(os.path.join(
self.config['data_path'],
dataset,
self.config['metafile_dir']
))
if os.path.isfile(os.path.join(
self.config['data_path'],
dataset,
self.config['metafile_dir'],
f
))
]
resource_files = self._remove_hidden_files(file_list)
log.debug(resource_files)
# for resource_file in resource_files:
for resource_file in (x for x in resource_files if x != 'meta.xml'):
resource_path = os.path.join(
self.config['data_path'],
dataset,
self.config['metafile_dir'],
resource_file
)
if resource_file == 'link.xml':
with retry_open_file(resource_path, 'r') as links_xml:
links = (
etree.parse(links_xml)
.findall('link')
)
for link in links:
url = self._get(link, 'url')
if url:
# generate hash for URL
md5 = hashlib.md5()
md5.update(url)
resources.append({
'url': url,
'zh_hash': md5.hexdigest(),
'name': self._get(link, 'lable'),
'description': self._get(link, 'description'),
'format': self._get(link, 'type'),
'resource_type': 'api',
})
else:
resource_file = self._validate_filename(resource_file)
if resource_file:
resource_dict = {
'name': resource_file,
'url': '',
'format': resource_file.split('.')[-1],
'resource_type': 'file'
}
# calculate the hash of this file
BUF_SIZE = 65536 # lets read stuff in 64kb chunks!
md5 = hashlib.md5()
with retry_open_file(resource_path, 'rb') as f:
while True:
data = f.read(BUF_SIZE)
if not data:
break
md5.update(data)
resource_dict['zh_hash'] = md5.hexdigest()
# add file to FieldStorage
with retry_open_file(resource_path, 'r', close=False) as f: # noqa
field_storage = FieldStorage()
field_storage.file = f
field_storage.filename = f.name
resource_dict['upload'] = field_storage
resources.append(resource_dict)
sorted_resources = sorted(
resources,
cmp=lambda x, y: self._sort_resource(x, y)
)
return sorted_resources
setOfRatedMovieNames.add(output['name'])
#get all names from movies
cursor.execute("""SELECT name FROM movies""")
table = cursor.fetchall()
setOfAllMovieNames = set()
for row in table:
setOfAllMovieNames.add(row['name'])
#take one from the other and put it in movieList
setOfUnratedMovieNames = setOfAllMovieNames - setOfRatedMovieNames
movieList = "<p>Here's a list of all of the movies you have not yet rated:"
for movieName in setOfUnratedMovieNames:
movieList = movieList + str(movieName) + "</br>"
movieList = movieList + "</p>"
##############################################################
form_data = FieldStorage()
movie = ''
score = ''
if len(form_data) != 0:
movie = escape(form_data.getfirst('movie', '').strip())
score = escape(form_data.getfirst('score', '').strip())
if not movie or not score:
error = '<p>Error: movie and score are required</p>'
elif not score.isdigit():
error = '<p>Error: score must be a digit</p>'
elif int(score) > 5 or int(score) < 0:
error = '<p>Error: score must be above 0 and equal to or below 5</p>'
elif movie not in setOfUnratedMovieNames:
error = '<p>Error: movie must be in the list that is below</p>'
else:
try:
def test_notification_two_attaches():
d = M.Discussion(shortname='test', name='test')
t = M.Thread.new(discussion_id=d._id, subject='Test comment notification')
fs1 = FieldStorage()
fs1.name = 'file_info'
fs1.filename = 'fake.txt'
fs1.type = 'text/plain'
fs1.file = StringIO('this is the content of the fake file\n')
fs2 = FieldStorage()
fs2.name = 'file_info'
fs2.filename = 'fake2.txt'
fs2.type = 'text/plain'
fs2.file = StringIO('this is the content of the fake file\n')
p = t.post(text=u'test message',
forum=None,
subject='',
file_info=[fs1, fs2])
ThreadLocalORMSession.flush_all()
n = M.Notification.query.get(
subject=u'[test:wiki] Test comment notification')
base_url = h.absurl('{}attachment/'.format(p.url()))
assert_in(
'\nAttachments:\n\n'
'- [fake.txt]({0}fake.txt) (37 Bytes; text/plain)\n'
'- [fake2.txt]({0}fake2.txt) (37 Bytes; text/plain)'.format(base_url),
n.text)
from unittest import TestCase
import pretend
import pytest
from pyramid.httpexceptions import HTTPNotFound
from sqlalchemy.orm.exc import NoResultFound
from webob.multidict import MultiDict
from warehouse.admin.interfaces import ISponsorLogoStorage
from warehouse.admin.views import sponsors as views
from warehouse.sponsors.models import Sponsor
from ....common.db.sponsors import SponsorFactory
COLOR_LOGO_FILE = FieldStorage()
COLOR_LOGO_FILE.filename = "colorlogo.png"
COLOR_LOGO_FILE.file = io.BytesIO((
b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01\x08\x06"
b"\x00\x00\x00\x1f\x15\xc4\x89\x00\x00\x00\rIDATx\xdac\xfc\xcf\xc0P\x0f\x00"
b"\x04\x85\x01\x80\x84\xa9\x8c!\x00\x00\x00\x00IEND\xaeB`\x82"))
COLOR_LOGO_FILE.type = "image/png"
WHITE_LOGO_FILE = FieldStorage()
WHITE_LOGO_FILE.filename = "whitelogo.png"
WHITE_LOGO_FILE.file = io.BytesIO((
b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01\x08\x06"
b"\x00\x00\x00\x1f\x15\xc4\x89\x00\x00\x00\rIDATx\xdac\xfc\xcf\xc0P\x0f\x00"
b"\x04\x85\x01\x80\x84\xa9\x8c!\x00\x00\x00\x00IEND\xaeB`\x82"))
WHITE_LOGO_FILE.type = "image/png"
http_cookie_header = environ.get('HTTP_COOKIE')
if not http_cookie_header:
sid = sha256(repr(time()).encode()).hexdigest()
cookie['sid'] = sid
else:
cookie.load(http_cookie_header)
if 'sid' not in cookie:
sid = sha256(repr(time()).encode()).hexdigest()
cookie['sid'] = sid
else:
sid = cookie['sid'].value
session_store = open('sess_' + sid, writeback=True)
# Get the id of the item being added to the cart
form_data = FieldStorage()
book_number = form_data.getfirst('book_number')
# If this item is not in the cart already, then quantity is 1; otherwise, increment the quantity.
qty = session_store.get(book_number)
if not qty:
qty = 1
else:
qty +=1
session_store[book_number] = qty
session_store.close()
print(cookie)
result = '<p>Item successfully added to your cart.</p>'
except IOError:
result = '<p>Sorry! We are experiencing problems at the moment. Please call back later.</p>'
def prepare_field_storage(name, x):
field_storage = FieldStorage()
field_storage.filename = name
field_storage.file = prepare_file(x)
return field_storage
restricted = "restricted"
sys.path.append(os.path.abspath(restricted))
from cgi import FieldStorage
from html import escape
import pymysql as db
import passwords
import funcs
from os import environ
from http.cookies import SimpleCookie
from time import time
import hashlib
form_data = FieldStorage()
result = ""
check = False
uname = form_data.getfirst("uname")
pwd = form_data.getfirst("pwd")
if uname:
uname = escape(uname, quote=False)
else:
uname = ""
if pwd:
pwd = escape(pwd, quote=False)
#!/usr/local/bin/python3
from cgi import FieldStorage
import pymysql as db
from cgitb import enable
enable()
print('Content-Type: text/html')
print()
form_data = FieldStorage()
country = ''
output = ''
if len(form_data) != 0:
try:
country = form_data.getfirst('country', '')
connection = db.connect('localhost', 'cf26', 'pecah',
'cs6503_cs1106_cf26')
cursor = connection.cursor(db.cursors.DictCursor)
cursor.execute("""SELECT * FROM winners WHERE country = %s""",
(country))
if len(cursor.fetchall()) != 0:
output = """<table>
<tr><th colspan="4">Eurovision Winners</th></tr>
<tr><th>Year</th><th>Song</th><th>Performer</th><th>Points</th></tr>"""
for row in cursor.fetchall():
print(len(row))
output += """<tr>
<td>%s</td>
#!/usr/local/bin/python3
from cgitb import enable
enable()
from cgi import FieldStorage
from html import escape
from hashlib import sha256
from time import time
from shelve import open
from http.cookies import SimpleCookie
form_data = FieldStorage()
attempt = ''
attempt2 = ''
result = ''
javascript = ''
colour_button = ''
paragraph = ""
score = 0
if len(form_data) != 0:
attempt = escape(form_data.getfirst('guess', '').strip())
attempt2 = escape(form_data.getfirst('guess2', '').strip())
attempt3 = escape(form_data.getfirst('guess3', '').strip())
attempt4 = escape(form_data.getfirst('guess4', '').strip())
attempt5 = escape(form_data.getfirst('guess5', '').strip())
try:
if attempt == "A":
score += 1
if attempt2 == "10":
dataID, sampleID)
cursor.execute(statement)
for row in cursor.fetchall():
return (row['sampleData'])
except (db.Error, IOError) as e:
print("Database error in getData code.py")
print(e)
url = ""
body = ""
print('Content-Type: text/html')
print()
cursor = getCursor()
form = FieldStorage()
def databaseForm(cursor):
selectDB = """<h1>Select Database: </h1> <select name="dbID">"""
try:
cursor.execute("""select distinct dataID from fypDB""")
# lst = []
for row in cursor.fetchall():
# lst+=[row['dataID']]
selectDB += """<option value="%s">%s</option>""" % (row['dataID'],
row['dataID'])
selectDB += "</select>"
formCode = (
msg = email.MIMEMultipart.MIMEMultipart()
msg['From'] = fromaddr
msg['To'] = email.Utils.COMMASPACE.join(tolist)
msg['Subject'] = subject
msg.attach(MIMEText(message))
msg.attach(MIMEText('\nSent from saas.mit.edu', 'plain'))
server.sendmail(user, tolist, msg.as_string())
def verify_email(email):
if not re.match(r"[^@]+@[^@]+\.[^@]+", email):
return False
return True
f = FieldStorage()
fromaddr = message = subject = None
error_msg = "Looks like you have a missing field or two!"
if "from" in f:
fromaddr = f["from"].value
if not verify_email(fromaddr):
fromaddr = None
error_msg = "Looks like the email you entered has a typo!"
if "message" in f:
message = f["message"].value
if "subject" in f:
subject = f["subject"].value
if fromaddr and message and subject:
# Success page
send_email(fromaddr, subject, message)
#!/usr/bin/python3
# Get available and valid places according to tile rotation
from cgitb import enable
enable()
from getGameController import *
print('Content-Type: text/plain')
print()
from cgi import FieldStorage, escape
gC = getGameController()
form_data = FieldStorage()
if len(form_data) != 0:
rotate = form_data.getfirst("rotate")
if rotate == "True":
validPlaces = gC.rotateTile()
else:
validPlaces = gC.getValidTilePlacements()
setGameController(gC)
ret_str = ""
for cell in validPlaces:
ret_str += "%s,%s " % (cell[0], cell[1])
print(ret_str)
#!/usr/local/bin/python3
from cgitb import enable
enable()
from cgi import FieldStorage
from html import escape
from time import strptime
import pymysql as db
print('Content-Type: text/html')
print()
form_data =FieldStorage()
bandname =''
gig_date =''
result =''
if len(form_data) > 0:
try:
bandname = escape(form_data.getfirst('bandname', '').strip())
gig_date = escape(form_data.getfirst('gig_date', '').strip())
if bandname or gig_date:
connection = db.connect('cs1.ucc.ie', 'sv6', 'oguri', 'cs6503_cs1106_sv6')
cursor = connection.cursor(db.cursors.DictCursor)
if bandname:
cursor.execute("""SELECT * FROM gigs
WHERE bandname = %s""", (bandname))
if cursor.rowcount == 0:
result = """<p>Unknown band name</p>"""
if gig_date:
try:
valid_date = strptime(gig_date, '%Y-%m-%d')
except ValueError:
result+= """<p>Illegal date </p>"""
<label>
<input type="checkbox" value="remember-me"> Remember me
</label>
</div>
<button class="landing btn btn-lg btn-primary btn-block" type="submit">Sign in</button>
</form>
<script src="https://code.jquery.com/jquery-3.4.1.slim.min.js" integrity="sha384-J6qa4849blE2+poT4WnyKhv5vZF5SrPo0iEjwBvKU7imGFAV0wwj1yYfoRSJoZ+n" crossorigin="anonymous"></script>
<script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/umd/popper.min.js" integrity="sha384-Q6E9RHvbIyZFJoft+2mJbHaEWldlvI9IOYy5n3zV9zzTtmI3UksdQRVvoxMfooAo" crossorigin="anonymous"></script>
<script src="https://stackpath.bootstrapcdn.com/bootstrap/4.4.1/js/bootstrap.min.js" integrity="sha384-wfSDF2E50Y2D1uUdj0O3uMBJnjuUD4Ih7YwaYd1iqfktj0Uod8GCExl3Og8ifwB6" crossorigin="anonymous"></script>
</body>"""
cookie = SimpleCookie()
http_cookie_header = environ.get('HTTP_COOKIE')
form_data = FieldStorage()
email = escape(form_data.getfirst('email', "").strip())
password = escape(form_data.getfirst('password', "").strip())
if email != '':
connection = db.connect('cs1.ucc.ie', 'rjf1', 'ahf1Aeho', '2021_rjf1')
cursor = connection.cursor(db.cursors.DictCursor)
search_result = cursor.execute(
"""SELECT * FROM users WHERE email = %s AND password = %s""",
(email, password))
fetched = cursor.fetchone()
name = fetched['first_name'] + ' ' + fetched['last_name']
id = fetched['id']
account_type = fetched['account_type']
current_class = str(fetched['class'])
<li><a href="streaming.py">Browse</a></li>
<li><a href="login.py">Login</a></li>
<li><a href="register.py">Register</a></li>
</ul>
</nav>
</header>'''
page = """
<main>
<p>You do not have permission to access this page.</p>
<ul>
<li><a href="register.py">Register</a></li>
<li><a href="login.py">Login</a></li>
</ul>
</main>
"""
form_data = FieldStorage()
song_id = ''
playlist = ''
username = ''
try:
cookie = SimpleCookie()
http_cookie_header = environ.get('HTTP_COOKIE')
if http_cookie_header:
cookie.load(http_cookie_header)
if 'sid' in cookie:
sid = cookie['sid'].value
session_store = open('sess_' + sid, writeback=False)
if session_store.get('authenticated'):
username = (session_store.get('username'))
playlist = escape(form_data.getfirst('playlist', ''))
#!/usr/local/bin/python3
from cgitb import enable
enable()
from os import environ
from cgi import FieldStorage, escape
from hashlib import sha256 # Secure Hash Algorithm is a cryptographic hash function designed by the United States National Security Agency and is a U.S. Federal Information Processing Standard
from time import time
from shelve import open # A “shelf” is a persistent, dictionary-like object. The difference with “dbm” databases is that the values (not the keys!) in a shelf can be essentially arbitrary Python objects
from http.cookies import SimpleCookie
import pymysql as db
form_data = FieldStorage()
username=''
password=''
result = ''
result2=''
loggedIn=False
try:
cookie = SimpleCookie()
http_cookie_header = environ.get('HTTP_COOKIE')
if not http_cookie_header:
toy = sha256(repr(time()).encode()).hexdigest()
cookie['toy'] = toy
else:
cookie.load(http_cookie_header)
if 'toy' not in cookie:
toy = sha256(repr(time()).encode()).hexdigest()
def setup():
from base64 import urlsafe_b64encode, urlsafe_b64decode
from http.cookies import CookieError, SimpleCookie
from cgi import FieldStorage
from datetime import datetime
from decimal import Decimal
from json import JSONEncoder
from os import environ, path
from pickle import dumps, loads, UnpicklingError
from .pypp import preprocess
from sys import exit
class DecimalEncoder(JSONEncoder):
def default(self, obj):
nonlocal Decimal, JSONEncoder
if isinstance(obj, Decimal):
return str(obj)
return JSONEncoder.default(self, obj)
global toJSON, toHiddenJSON
def toJSON(obj):
nonlocal DecimalEncoder
return DecimalEncoder().encode(obj)
def toHiddenJSON(obj):
nonlocal DecimalEncoder
return toJSON(obj).replace("&", "&").replace("'", "&39;")
new_cookies = SimpleCookie()
form = FieldStorage()
fields = {}
moon = datetime(1969, 7, 21, 2, 56)
try:
old_cookies = SimpleCookie(environ['HTTP_COOKIE'])
except (CookieError, KeyError):
old_cookies = {}
global getCookie, setCookie, deleteCookie
def getCookie(name):
nonlocal old_cookies
try:
return old_cookies[name].value
except KeyError:
return None
def setCookie(name, value):
nonlocal new_cookies
new_cookies[name] = value
new_cookies[name]['expires'] = '0'
def deleteCookie(name):
nonlocal new_cookies, moon
new_cookies[name] = 'expiring'
new_cookies[name]['expires'] = moon.strftime("%a, %d-%b-%Y %H:%M:%S GMT")
global getField, containsField, setField, saveFields, loadFields
def getField(name, one = True):
nonlocal form, fields
fields[name] = fields.get(name, form.getfirst(name) if one else form.getlist(name))
return fields[name]
def containsField(name):
nonlocal form, fields
return name in fields or name in form
def setField(name, value):
nonlocal fields
fields[name] = value
def saveFields():
nonlocal fields, urlsafe_b64encode, dumps
return str(urlsafe_b64encode(dumps(fields,-1)))[2:-1]
def loadFields(dictionary):
nonlocal fields, loads, urlsafe_b64decode, UnpicklingError
try:
if dictionary:
fields = loads(urlsafe_b64decode(bytes(dictionary, 'utf-8')))
except UnpicklingError:
pass
global redirect, serve, AJAX, error
def redirect(loc):
nonlocal new_cookies
print("Location: %s" % loc)
print(new_cookies.output(sep = '\n'))
print()
exit(0)
def AJAX(doc):
global toJSON
print("Content-type: text/plain")
print()
print(toJSON(doc))
exit(0)
def serve(name):
global values
nonlocal preprocess, new_cookies, path
values['__COOKIES__'] = new_cookies.output(sep = '\n')
folder = name.rsplit(".", 1)[1]
try:
preprocess(path.join(folder, name), values, None, "html")
except IOError as e:
if e.errno == 2:
error(name, 404)
else:
raise
preprocess(path.join(folder, name), values, root="html")
exit(0)
errmessages = {
404 : 'Not Found'
}
def error(name, errno):
global values
nonlocal errmessages
values['__ERRFILE__'] = name
values['__ERRNO__'] = errno
values['__ERRMESSAGE__'] = errmessages[errno]
preprocess(path.join('html', '%d.html' % str(errno)), values)
exit(0)
try:
setField('query_string', '?%s' % environ['QUERY_STRING'])
except KeyError:
setField('query_string', '')
global values
values = {
'query_string' : getField('query_string'),
'redirect' : ''
}
values['site_path'] = path.dirname(environ['SCRIPT_NAME'])
values['file_path'] = environ['REDIRECT_URL'][len(values['site_path']):]
if not path.splitext(values['file_path'])[1]:
values['file_path'] = path.join(values['file_path'], '')
values['file_dir'], values['file_name'] = path.split(values['file_path'])
if not values['file_name']:
values['file_name'] = 'index.html'
values['file_path'] = path.join(values['file_dir'],values['file_name'])
#!/usr/bin/python3
from cgi import FieldStorage
from json import dumps, loads
import os
args = FieldStorage()
error = 'Status: 200 OK\n'
content = 'Content-Type: text/html\n\n'
output = None
if 'SSL_CLIENT_S_DN_Email' in os.environ:
output = {"kerb": os.environ['SSL_CLIENT_S_DN_Email']}
# add to database or something more fancy, probably create a password, do fancy checks and stuff
else:
error = 'Status: 401 Unauthorized\n'
# click this link -- whatever you're at now plus https and :444
# e.g. res.send("no certificate, please visit https://minecraft.scripts.mit.edu:444");
print(error + content)
print(dumps(output))