mj-saunders
/
epicyon
forked from indymedia/epicyon
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
epicyon/daemon.py

1621 lines
81 KiB
Python
Raw Normal View History

Initial
2019-06-28 18:55:29 +00:00
__filename__ = "daemon.py"
__author__ = "Bob Mottram"
__license__ = "AGPL3+"
__version__ = "0.0.1"
__maintainer__ = "Bob Mottram"
__email__ = "bob@freedombone.net"
__status__ = "Production"
Test for strict capabilities enforcement
2019-07-07 19:25:38 +00:00
from http.server import BaseHTTPRequestHandler,ThreadingHTTPServer
Initial
2019-06-28 18:55:29 +00:00
#import socketserver
GET individual posts
2019-07-06 21:24:47 +00:00
import commentjson
Initial
2019-06-28 18:55:29 +00:00
import json
Fallbacks for GET and POST locking
2019-07-01 14:30:48 +00:00
import time
Save image when receiving new post
2019-07-27 20:30:58 +00:00
import base64
# used for mime decoding of message POST
import email.parser
# for saving images
from binascii import a2b_base64
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
from hashlib import sha256
Initial
2019-06-28 18:55:29 +00:00
from pprint import pprint
from session import createSession
from webfinger import webfingerMeta
from webfinger import webfingerLookup
Test servers on different ip addresses
2019-07-01 21:01:43 +00:00
from webfinger import webfingerHandle
Initial
2019-06-28 18:55:29 +00:00
from person import personLookup
Generic in/outbox functions
2019-07-04 16:24:23 +00:00
from person import personBoxJson
Move shared inbox account into daemon
2019-07-11 12:29:31 +00:00
from person import createSharedInbox
Client to server posts overwrite some parameters
2019-07-03 22:16:03 +00:00
from posts import outboxMessageCreateWrap
Generic in/outbox functions
2019-07-04 16:24:23 +00:00
from posts import savePostToBox
c2s post distribution to followers
2019-07-15 17:22:51 +00:00
from posts import sendToFollowers
from posts import postIsAddressedToPublic
c2s sending to named addresses
2019-07-15 18:20:52 +00:00
from posts import sendToNamedAddresses
Connect new posts to web interface
2019-07-27 22:48:34 +00:00
from posts import createPublicPost
Handle unlisted posts
2019-07-28 11:08:14 +00:00
from posts import createUnlistedPost
Connect new posts to web interface
2019-07-27 22:48:34 +00:00
from posts import createFollowersOnlyPost
from posts import createDirectMessagePost
inbox functions
2019-06-28 21:59:54 +00:00
from inbox import inboxPermittedMessage
Check inbox items for expected params
2019-07-02 15:07:27 +00:00
from inbox import inboxMessageHasParams
inbox queue
2019-07-04 12:23:53 +00:00
from inbox import runInboxQueue
Fixing public key lookup
2019-07-04 14:36:29 +00:00
from inbox import savePostToInboxQueue
Following and followers feeds
2019-06-29 20:21:37 +00:00
from follow import getFollowingFeed
unfollowing functions
2019-07-17 10:34:00 +00:00
from follow import outboxUndoFollow
Tests for basic authentication
2019-07-03 18:24:44 +00:00
from auth import authorize
Move images to the media directory
2019-07-16 16:08:21 +00:00
from auth import createPassword
Start of login screen
2019-07-24 22:38:42 +00:00
from auth import createBasicAuthHeader
from auth import authorizeBasic
inbox queue
2019-07-04 12:23:53 +00:00
from threads import threadWithTrace
Move images to the media directory
2019-07-16 16:08:21 +00:00
from media import getMediaPath
from media import createMediaDirs
Test for post deletion
2019-07-17 17:16:48 +00:00
from delete import outboxDelete
Allow deletes in tests
2019-07-17 19:31:52 +00:00
from like import outboxLike
Undoing of likes view c2s
2019-07-17 19:55:24 +00:00
from like import outboxUndoLike
c2s blocking
2019-07-17 21:40:56 +00:00
from blocking import outboxBlock
from blocking import outboxUndoBlock
First account gets admin status
2019-07-18 13:10:26 +00:00
from config import setConfigParam
Functions for role delegation
2019-07-18 15:09:23 +00:00
from roles import outboxDelegate
Notes on skills
2019-07-19 10:01:24 +00:00
from skills import outboxSkills
Setting availability via c2s
2019-07-19 11:38:37 +00:00
from availability import outboxAvailability
Begin on a web interface
2019-07-20 21:13:36 +00:00
from webinterface import htmlIndividualPost
from webinterface import htmlProfile
from webinterface import htmlInbox
from webinterface import htmlOutbox
from webinterface import htmlPostReplies
Start of login screen
2019-07-24 22:38:42 +00:00
from webinterface import htmlLogin
from webinterface import htmlGetLoginCredentials
New post screen
2019-07-25 21:39:09 +00:00
from webinterface import htmlNewPost
Functions for shared items
2019-07-23 12:33:09 +00:00
from shares import getSharesFeedForPerson
Uploading shared items
2019-07-23 20:00:17 +00:00
from shares import outboxShareUpload
Undo shared items
2019-07-23 21:14:16 +00:00
from shares import outboxUndoShareUpload
Posting shares from the web interface
2019-07-28 08:34:49 +00:00
from shares import addShare
Initial
2019-06-28 18:55:29 +00:00
import os
reject giant messages
2019-06-28 21:06:05 +00:00
import sys
Initial
2019-06-28 18:55:29 +00:00
GET on outbox
2019-06-29 14:35:26 +00:00
# maximum number of posts to list in outbox feed
maxPostsInFeed=20
Following and followers feeds
2019-06-29 20:21:37 +00:00
# number of follows/followers per page
Use federation list for followers
2019-06-29 20:34:41 +00:00
followsPerPage=12
Following and followers feeds
2019-06-29 20:21:37 +00:00
Functions for shared items
2019-07-23 12:33:09 +00:00
# number of item shares per page
sharesPerPage=12
Initial
2019-06-28 18:55:29 +00:00
def readFollowList(filename: str):
"""Returns a list of ActivityPub addresses to follow
"""
followlist=[]
if not os.path.isfile(filename):
return followlist
followUsers = open(filename, "r")
for u in followUsers:
if u not in followlist:
Change username to nickname
2019-07-03 09:40:27 +00:00
nickname,domain = parseHandle(u)
if nickname:
followlist.append(nickname+'@'+domain)
Following and followers feeds
2019-06-29 20:21:37 +00:00
followUsers.close()
Initial
2019-06-28 18:55:29 +00:00
return followlist
class PubServer(BaseHTTPRequestHandler):
Include host in headers
2019-07-25 09:13:02 +00:00
def _login_headers(self,fileFormat: str) -> None:
Initial
2019-06-28 18:55:29 +00:00
self.send_response(200)
self.send_header('Content-type', fileFormat)
Include host in headers
2019-07-25 09:13:02 +00:00
self.send_header('Host', self.server.domainFull)
Login screen redirects
2019-07-25 10:56:24 +00:00
self.send_header('WWW-Authenticate', 'title="Login to Epicyon", Basic realm="epicyon"')
Initial
2019-06-28 18:55:29 +00:00
self.end_headers()
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
def _set_headers(self,fileFormat: str) -> None:
Include host in headers
2019-07-25 09:13:02 +00:00
self.send_response(200)
self.send_header('Content-type', fileFormat)
self.send_header('Host', self.server.domainFull)
self.end_headers()
Redirect after post
2019-07-28 14:09:48 +00:00
def _redirect_headers(self,redirect: str) -> None:
self.send_response(303)
self.send_header('Content-type', 'text/html')
self.send_header('Location', redirect)
self.send_header('Host', self.server.domainFull)
self.end_headers()
Client to server posts overwrite some parameters
2019-07-03 22:16:03 +00:00
def _404(self) -> None:
Initial
2019-06-28 18:55:29 +00:00
self.send_response(404)
self.send_header('Content-Type', 'text/html; charset=utf-8')
self.end_headers()
self.wfile.write("<html><head></head><body><h1>404 Not Found</h1></body></html>".encode('utf-8'))
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
def _webfinger(self) -> bool:
Initial
2019-06-28 18:55:29 +00:00
if not self.path.startswith('/.well-known'):
return False
Fixing public key lookup
2019-07-04 14:36:29 +00:00
if self.server.debug:
print('DEBUG: WEBFINGER well-known')
Initial
2019-06-28 18:55:29 +00:00
Debug option
2019-07-03 16:14:45 +00:00
if self.server.debug:
print('DEBUG: WEBFINGER host-meta')
Initial
2019-06-28 18:55:29 +00:00
if self.path.startswith('/.well-known/host-meta'):
wfResult=webfingerMeta()
if wfResult:
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('application/xrd+xml')
Initial
2019-06-28 18:55:29 +00:00
self.wfile.write(wfResult.encode('utf-8'))
return
Debug option
2019-07-03 16:14:45 +00:00
if self.server.debug:
print('DEBUG: WEBFINGER lookup '+self.path+' '+str(self.server.baseDir))
Back to no port number on webfinger acct
2019-07-19 14:41:32 +00:00
wfResult=webfingerLookup(self.path,self.server.baseDir,self.server.port,self.server.debug)
Initial
2019-06-28 18:55:29 +00:00
if wfResult:
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('application/jrd+json')
Initial
2019-06-28 18:55:29 +00:00
self.wfile.write(json.dumps(wfResult).encode('utf-8'))
else:
Debug option
2019-07-03 16:14:45 +00:00
if self.server.debug:
print('DEBUG: WEBFINGER lookup 404 '+self.path)
Initial
2019-06-28 18:55:29 +00:00
self._404()
return True
Client to server posts overwrite some parameters
2019-07-03 22:16:03 +00:00
def _permittedDir(self,path: str) -> bool:
"""These are special paths which should not be accessible
directly via GET or POST
"""
Initial
2019-06-28 18:55:29 +00:00
if path.startswith('/wfendpoints') or \
path.startswith('/keys') or \
path.startswith('/accounts'):
return False
return True
self
2019-07-05 11:41:09 +00:00
def _postToOutbox(self,messageJson: {}) -> bool:
Client to server posts overwrite some parameters
2019-07-03 22:16:03 +00:00
"""post is received by the outbox
Client to server message post
https://www.w3.org/TR/activitypub/#client-to-server-outbox-delivery
"""
Create id of object
2019-07-03 22:59:56 +00:00
if not messageJson.get('type'):
Save posts to inbox to a queue
2019-07-04 10:02:56 +00:00
if self.server.debug:
print('DEBUG: POST to outbox has no "type" parameter')
Create id of object
2019-07-03 22:59:56 +00:00
return False
if not messageJson.get('object') and messageJson.get('content'):
if messageJson['type']!='Create':
# https://www.w3.org/TR/activitypub/#object-without-create
if self.server.debug:
Save posts to inbox to a queue
2019-07-04 10:02:56 +00:00
print('DEBUG: POST to outbox - adding Create wrapper')
Create id of object
2019-07-03 22:59:56 +00:00
messageJson= \
outboxMessageCreateWrap(self.server.httpPrefix, \
self.postToNickname, \
Fixing c2s
2019-07-16 10:19:04 +00:00
self.server.domain, \
self.server.port, \
messageJson)
Allow for other outbox post types
2019-07-03 22:44:03 +00:00
if messageJson['type']=='Create':
if not (messageJson.get('id') and \
messageJson.get('type') and \
messageJson.get('actor') and \
messageJson.get('object') and \
messageJson.get('to')):
if self.server.debug:
Fixing c2s
2019-07-16 10:19:04 +00:00
pprint(messageJson)
Save posts to inbox to a queue
2019-07-04 10:02:56 +00:00
print('DEBUG: POST to outbox - Create does not have the required parameters')
Allow for other outbox post types
2019-07-03 22:44:03 +00:00
return False
# https://www.w3.org/TR/activitypub/#create-activity-outbox
messageJson['object']['attributedTo']=messageJson['actor']
Move images to the media directory
2019-07-16 16:08:21 +00:00
if messageJson['object'].get('attachment'):
attachmentIndex=0
if messageJson['object']['attachment'][attachmentIndex].get('mediaType'):
fileExtension='png'
if messageJson['object']['attachment'][attachmentIndex]['mediaType'].endswith('jpeg'):
fileExtension='jpg'
if messageJson['object']['attachment'][attachmentIndex]['mediaType'].endswith('gif'):
fileExtension='gif'
mediaDir=self.server.baseDir+'/accounts/'+self.postToNickname+'@'+self.server.domain
uploadMediaFilename=mediaDir+'/upload.'+fileExtension
if not os.path.isfile(uploadMediaFilename):
del messageJson['object']['attachment']
else:
# generate a path for the uploaded image
mPath=getMediaPath()
mediaPath=mPath+'/'+createPassword(32)+'.'+fileExtension
createMediaDirs(self.server.baseDir,mPath)
mediaFilename=self.server.baseDir+'/'+mediaPath
# move the uploaded image to its new path
os.rename(uploadMediaFilename,mediaFilename)
# change the url of the attachment
messageJson['object']['attachment'][attachmentIndex]['url']= \
self.server.httpPrefix+'://'+self.server.domain+'/'+mediaPath
Reduce some line lengths
2019-07-06 17:00:22 +00:00
permittedOutboxTypes=[
'Create','Announce','Like','Follow','Undo', \
Functions for role delegation
2019-07-18 15:09:23 +00:00
'Update','Add','Remove','Block','Delete', \
Notes on skills
2019-07-19 10:01:24 +00:00
'Delegate','Skill'
Reduce some line lengths
2019-07-06 17:00:22 +00:00
]
Allow for other outbox post types
2019-07-03 22:44:03 +00:00
if messageJson['type'] not in permittedOutboxTypes:
if self.server.debug:
Reduce some line lengths
2019-07-06 17:00:22 +00:00
print('DEBUG: POST to outbox - '+messageJson['type']+ \
' is not a permitted activity type')
Client to server posts overwrite some parameters
2019-07-03 22:16:03 +00:00
return False
Create id of object
2019-07-03 22:59:56 +00:00
if messageJson.get('id'):
Test follow via c2s
2019-07-16 21:38:06 +00:00
postId=messageJson['id'].replace('/activity','')
Fix ports on post filenames
2019-07-18 11:35:48 +00:00
if self.server.debug:
print('DEBUG: id attribute exists within POST to outbox')
Create id of object
2019-07-03 22:59:56 +00:00
else:
Fix ports on post filenames
2019-07-18 11:35:48 +00:00
if self.server.debug:
print('DEBUG: No id attribute within POST to outbox')
Create id of object
2019-07-03 22:59:56 +00:00
postId=None
Fixing c2s
2019-07-16 10:19:04 +00:00
if self.server.debug:
pprint(messageJson)
Test for post deletion
2019-07-17 17:16:48 +00:00
print('DEBUG: savePostToBox')
Fix ports on post filenames
2019-07-18 11:35:48 +00:00
domainFull=self.server.domain
if self.server.port!=80 and self.server.port!=443:
domainFull=self.server.domain+':'+str(self.server.port)
Fixing c2s
2019-07-16 10:19:04 +00:00
savePostToBox(self.server.baseDir, \
self.server.httpPrefix, \
postId, \
c2s sending to named addresses
2019-07-15 18:20:52 +00:00
self.postToNickname, \
Fix ports on post filenames
2019-07-18 11:35:48 +00:00
domainFull,messageJson,'outbox')
Fixing c2s
2019-07-16 10:19:04 +00:00
if not self.server.session:
debug
2019-07-16 10:20:03 +00:00
if self.server.debug:
print('DEBUG: creating new session for c2s')
Fixing c2s
2019-07-16 10:19:04 +00:00
self.server.session= \
createSession(self.server.domain,self.server.port,self.server.useTor)
c2s post distribution to followers
2019-07-15 17:22:51 +00:00
if self.server.debug:
print('DEBUG: sending c2s post to followers')
sendToFollowers(self.server.session,self.server.baseDir, \
Fixing c2s
2019-07-16 10:19:04 +00:00
self.postToNickname,self.server.domain, \
self.server.port, \
self.server.httpPrefix, \
self.server.federationList, \
self.server.sendThreads, \
self.server.postLog, \
self.server.cachedWebfingers, \
self.server.personCache, \
messageJson,self.server.debug)
unfollowing functions
2019-07-17 10:34:00 +00:00
if self.server.debug:
print('DEBUG: handle any unfollow requests')
outboxUndoFollow(self.server.baseDir,messageJson,self.server.debug)
Functions for role delegation
2019-07-18 15:09:23 +00:00
if self.server.debug:
print('DEBUG: handle delegation requests')
Notes on skills
2019-07-19 10:01:24 +00:00
outboxDelegate(self.server.baseDir,self.postToNickname,messageJson,self.server.debug)
if self.server.debug:
Setting availability via c2s
2019-07-19 11:38:37 +00:00
print('DEBUG: handle skills changes requests')
Notes on skills
2019-07-19 10:01:24 +00:00
outboxSkills(self.server.baseDir,self.postToNickname,messageJson,self.server.debug)
Setting availability via c2s
2019-07-19 11:38:37 +00:00
if self.server.debug:
print('DEBUG: handle availability changes requests')
outboxAvailability(self.server.baseDir,self.postToNickname,messageJson,self.server.debug)
Allow deletes in tests
2019-07-17 19:31:52 +00:00
if self.server.debug:
print('DEBUG: handle any like requests')
outboxLike(self.server.baseDir,self.server.httpPrefix, \
self.postToNickname,self.server.domain,self.server.port, \
messageJson,self.server.debug)
Undoing of likes view c2s
2019-07-17 19:55:24 +00:00
if self.server.debug:
print('DEBUG: handle any undo like requests')
outboxUndoLike(self.server.baseDir,self.server.httpPrefix, \
self.postToNickname,self.server.domain,self.server.port, \
messageJson,self.server.debug)
Allow authenticated deletion
2019-07-17 17:58:08 +00:00
if self.server.debug:
print('DEBUG: handle delete requests')
Prohibit deletions of posts not owned by the deletion requester
2019-07-17 18:05:07 +00:00
outboxDelete(self.server.baseDir,self.server.httpPrefix, \
self.postToNickname,self.server.domain, \
messageJson,self.server.debug)
c2s blocking
2019-07-17 21:40:56 +00:00
if self.server.debug:
print('DEBUG: handle block requests')
outboxBlock(self.server.baseDir,self.server.httpPrefix, \
self.postToNickname,self.server.domain, \
self.server.port,
messageJson,self.server.debug)
if self.server.debug:
print('DEBUG: handle undo block requests')
outboxUndoBlock(self.server.baseDir,self.server.httpPrefix, \
self.postToNickname,self.server.domain, \
self.server.port,
messageJson,self.server.debug)
Uploading shared items
2019-07-23 20:00:17 +00:00
if self.server.debug:
print('DEBUG: handle share uploads')
outboxShareUpload(self.server.baseDir,self.server.httpPrefix, \
self.postToNickname,self.server.domain, \
self.server.port,
messageJson,self.server.debug)
Undo shared items
2019-07-23 21:14:16 +00:00
if self.server.debug:
print('DEBUG: handle undo share uploads')
outboxUndoShareUpload(self.server.baseDir,self.server.httpPrefix, \
self.postToNickname,self.server.domain, \
self.server.port,
messageJson,self.server.debug)
c2s sending to named addresses
2019-07-15 18:20:52 +00:00
if self.server.debug:
print('DEBUG: sending c2s post to named addresses')
Fixing c2s
2019-07-16 10:19:04 +00:00
print('c2s sender: '+self.postToNickname+'@'+self.server.domain+':'+str(self.server.port))
c2s sending to named addresses
2019-07-15 18:20:52 +00:00
sendToNamedAddresses(self.server.session,self.server.baseDir, \
self.postToNickname,self.server.domain, \
self.server.port, \
self.server.httpPrefix, \
self.server.federationList, \
self.server.sendThreads, \
self.server.postLog, \
self.server.cachedWebfingers, \
self.server.personCache, \
messageJson,self.server.debug)
Client to server posts overwrite some parameters
2019-07-03 22:16:03 +00:00
return True
Posting via web interface
2019-07-28 13:30:19 +00:00
def _updateInboxQueue(self,nickname: str,messageJson: {},postFromWebInterface: bool) -> int:
Create shared inbox on start of daemon
2019-07-05 11:27:18 +00:00
"""Update the inbox queue
"""
Limit inbox queue length
2019-07-15 12:27:26 +00:00
# Check if the queue is full
if len(self.server.inboxQueue)>=self.server.maxQueueLength:
return 1
Fix ports on post filenames
2019-07-18 11:35:48 +00:00
domainFull=self.server.domain
if self.server.port!=80 and self.server.port!=443:
domainFull=self.server.domain+':'+str(self.server.port)
# save the json for later queue processing
Test for follow request
2019-07-06 13:49:25 +00:00
queueFilename = \
Create shared inbox on start of daemon
2019-07-05 11:27:18 +00:00
savePostToInboxQueue(self.server.baseDir, \
self.server.httpPrefix, \
nickname, \
Fix ports on post filenames
2019-07-18 11:35:48 +00:00
domainFull, \
Create shared inbox on start of daemon
2019-07-05 11:27:18 +00:00
messageJson,
self.headers['host'],
More generic postPath
2019-07-05 22:13:20 +00:00
self.headers['signature'],
Test for follow request
2019-07-06 13:49:25 +00:00
'/'+self.path.split('/')[-1],
Posting via web interface
2019-07-28 13:30:19 +00:00
postFromWebInterface,
Test for follow request
2019-07-06 13:49:25 +00:00
self.server.debug)
if queueFilename:
Limit inbox queue length
2019-07-15 12:27:26 +00:00
# add json to the queue
Test for follow request
2019-07-06 13:49:25 +00:00
if queueFilename not in self.server.inboxQueue:
self.server.inboxQueue.append(queueFilename)
Create shared inbox on start of daemon
2019-07-05 11:27:18 +00:00
self.send_response(201)
self.end_headers()
self.server.POSTbusy=False
Limit inbox queue length
2019-07-15 12:27:26 +00:00
return 0
return 2
Create shared inbox on start of daemon
2019-07-05 11:27:18 +00:00
Tidying
2019-07-12 11:05:43 +00:00
def _isAuthorized(self) -> bool:
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
# token based authenticated used by the web interface
if self.headers.get('Cookie'):
if '=' in self.headers['Cookie']:
tokenStr=self.headers['Cookie'].split('=',1)[1]
if self.server.tokensLookup.get(tokenStr):
nickname=self.server.tokensLookup[tokenStr]
if '/'+nickname+'/' in self.path:
return True
if self.path.endswith('/'+nickname):
return True
return False
# basic auth
Tidying
2019-07-12 11:05:43 +00:00
if self.headers.get('Authorization'):
if authorize(self.server.baseDir,self.path, \
self.headers['Authorization'], \
self.server.debug):
return True
return False
Retain the authorized header
2019-07-25 11:18:35 +00:00
def do_GET(self):
Debug option
2019-07-03 16:14:45 +00:00
if self.server.debug:
Reduce some line lengths
2019-07-06 17:00:22 +00:00
print('DEBUG: GET from '+self.server.baseDir+ \
' path: '+self.path+' busy: '+ \
str(self.server.GETbusy))
Retain the authorized header
2019-07-25 11:18:35 +00:00
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
if self.server.debug:
print(str(self.headers))
# check authorization
Retain the authorized header
2019-07-25 11:18:35 +00:00
authorized = self._isAuthorized()
if authorized:
if self.server.debug:
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
print('GET Authorization granted')
Retain the authorized header
2019-07-25 11:18:35 +00:00
else:
if self.server.debug:
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
print('GET Not authorized')
Only show web interface after login
2019-07-25 16:03:58 +00:00
# if not authorized then show the login screen
if self.headers.get('Accept'):
if 'text/html' in self.headers['Accept'] and self.path!='/login':
New post scope
2019-07-26 12:26:41 +00:00
if '/media/' not in self.path and \
'/sharefiles/' not in self.path and \
'/icons/' not in self.path:
Posting via web interface
2019-07-28 13:30:19 +00:00
divertToLoginScreen=True
if self.path.startswith('/users/'):
if '/' not in self.path.split('/users/')[1]:
divertToLoginScreen=False
else:
if self.path.endswith('/following') or \
self.path.endswith('/followers') or \
self.path.endswith('/skills') or \
self.path.endswith('/roles') or \
self.path.endswith('/shares'):
divertToLoginScreen=False
if divertToLoginScreen and not authorized:
Full path on shares images
2019-07-25 16:15:02 +00:00
self.send_response(303)
self.send_header('Location', '/login')
self.end_headers()
self.server.POSTbusy=False
return
Retain the authorized header
2019-07-25 11:18:35 +00:00
Initial html timeline
2019-07-21 09:09:28 +00:00
# get css
# Note that this comes before the busy flag to avoid conflicts
if self.path.endswith('.css'):
Single css file
2019-07-24 11:03:56 +00:00
if os.path.isfile('epicyon-profile.css'):
with open('epicyon-profile.css', 'r') as cssfile:
Initial html timeline
2019-07-21 09:09:28 +00:00
css = cssfile.read()
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('text/css')
Initial html timeline
2019-07-21 09:09:28 +00:00
self.wfile.write(css.encode('utf-8'))
return
Start of login screen
2019-07-24 22:38:42 +00:00
# image on login screen
if self.path=='/login.png':
mediaFilename= \
self.server.baseDir+'/accounts/login.png'
if os.path.isfile(mediaFilename):
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('image/png')
Start of login screen
2019-07-24 22:38:42 +00:00
with open(mediaFilename, 'rb') as avFile:
mediaBinary = avFile.read()
self.wfile.write(mediaBinary)
return
Login screen customization
2019-07-25 19:56:25 +00:00
# login screen background image
if self.path=='/login-background.png':
mediaFilename= \
self.server.baseDir+'/accounts/login-background.png'
if os.path.isfile(mediaFilename):
self._set_headers('image/png')
with open(mediaFilename, 'rb') as avFile:
mediaBinary = avFile.read()
self.wfile.write(mediaBinary)
return
GET media
2019-07-12 19:33:34 +00:00
# show media
Avoid busy conflicts when grabbing media
2019-07-22 09:52:43 +00:00
# Note that this comes before the busy flag to avoid conflicts
GET media
2019-07-12 19:33:34 +00:00
if '/media/' in self.path:
if self.path.endswith('.png') or \
self.path.endswith('.jpg') or \
self.path.endswith('.gif'):
mediaStr=self.path.split('/media/')[1]
mediaFilename= \
self.server.baseDir+'/media/'+mediaStr
if os.path.isfile(mediaFilename):
if mediaFilename.endswith('.png'):
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('image/png')
GET media
2019-07-12 19:33:34 +00:00
elif mediaFilename.endswith('.jpg'):
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('image/jpeg')
GET media
2019-07-12 19:33:34 +00:00
else:
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('image/gif')
GET media
2019-07-12 19:33:34 +00:00
with open(mediaFilename, 'rb') as avFile:
mediaBinary = avFile.read()
self.wfile.write(mediaBinary)
return
404 if media isn't found
2019-07-16 16:10:52 +00:00
self._404()
return
Functions for shared items
2019-07-23 12:33:09 +00:00
# show shared item images
# Note that this comes before the busy flag to avoid conflicts
if '/sharefiles/' in self.path:
if self.path.endswith('.png') or \
self.path.endswith('.jpg') or \
self.path.endswith('.gif'):
mediaStr=self.path.split('/sharefiles/')[1]
mediaFilename= \
self.server.baseDir+'/sharefiles/'+mediaStr
if os.path.isfile(mediaFilename):
if mediaFilename.endswith('.png'):
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('image/png')
Functions for shared items
2019-07-23 12:33:09 +00:00
elif mediaFilename.endswith('.jpg'):
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('image/jpeg')
Functions for shared items
2019-07-23 12:33:09 +00:00
else:
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('image/gif')
Functions for shared items
2019-07-23 12:33:09 +00:00
with open(mediaFilename, 'rb') as avFile:
mediaBinary = avFile.read()
self.wfile.write(mediaBinary)
return
self._404()
return
Add scope icons
2019-07-26 10:30:13 +00:00
# icon images
# Note that this comes before the busy flag to avoid conflicts
New post scope
2019-07-26 12:26:41 +00:00
if self.path.startswith('/icons/'):
Add scope icons
2019-07-26 10:30:13 +00:00
if self.path.endswith('.png'):
mediaStr=self.path.split('/icons/')[1]
mediaFilename= \
self.server.baseDir+'/img/icons/'+mediaStr
if os.path.isfile(mediaFilename):
if mediaFilename.endswith('.png'):
self._set_headers('image/png')
with open(mediaFilename, 'rb') as avFile:
mediaBinary = avFile.read()
self.wfile.write(mediaBinary)
return
self._404()
return
Random token
2019-07-12 16:09:25 +00:00
# show avatar or background image
Avoid busy conflicts when grabbing media
2019-07-22 09:52:43 +00:00
# Note that this comes before the busy flag to avoid conflicts
GET avatar
2019-07-12 16:03:01 +00:00
if '/users/' in self.path:
if self.path.endswith('.png') or \
self.path.endswith('.jpg') or \
self.path.endswith('.gif'):
avatarStr=self.path.split('/users/')[1]
if '/' in avatarStr:
avatarNickname=avatarStr.split('/')[0]
avatarFile=avatarStr.split('/')[1]
avatarFilename= \
self.server.baseDir+'/accounts/'+ \
avatarNickname+'@'+ \
self.server.domain+'/'+avatarFile
if os.path.isfile(avatarFilename):
if avatarFile.endswith('.png'):
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('image/png')
GET avatar
2019-07-12 16:03:01 +00:00
elif avatarFile.endswith('.jpg'):
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('image/jpeg')
GET avatar
2019-07-12 16:03:01 +00:00
else:
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('image/gif')
GET avatar
2019-07-12 16:03:01 +00:00
with open(avatarFilename, 'rb') as avFile:
GET media
2019-07-12 19:33:34 +00:00
avBinary = avFile.read()
self.wfile.write(avBinary)
Comments
2019-07-22 15:14:39 +00:00
return
# This busy state helps to avoid flooding
# Resources which are expected to be called from a web page
# should be above this
Avoid busy conflicts when grabbing media
2019-07-22 09:52:43 +00:00
if self.server.GETbusy:
currTimeGET=int(time.time())
if currTimeGET-self.server.lastGET<10:
if self.server.debug:
print('DEBUG: GET Busy')
digest of sha256
2019-07-25 16:50:48 +00:00
self.send_response(429)
Avoid busy conflicts when grabbing media
2019-07-22 09:52:43 +00:00
self.end_headers()
return
self.server.lastGET=currTimeGET
self.server.GETbusy=True
if not self._permittedDir(self.path):
if self.server.debug:
print('DEBUG: GET Not permitted')
self._404()
self.server.GETbusy=False
return
# get webfinger endpoint for a person
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
if self._webfinger():
Avoid busy conflicts when grabbing media
2019-07-22 09:52:43 +00:00
self.server.GETbusy=False
return
Only show web interface after login
2019-07-25 16:03:58 +00:00
Start of login screen
2019-07-24 22:38:42 +00:00
if self.path.startswith('/login'):
# request basic auth
Include host in headers
2019-07-25 09:13:02 +00:00
self._login_headers('text/html')
Start of login screen
2019-07-24 22:38:42 +00:00
self.wfile.write(htmlLogin(self.server.baseDir).encode('utf-8'))
self.server.GETbusy=False
New post screen
2019-07-25 21:39:09 +00:00
return
New post scope
2019-07-26 12:26:41 +00:00
if '/users/' in self.path and \
(self.path.endswith('/newpost') or \
self.path.endswith('/newunlisted') or \
self.path.endswith('/newfollowers') or \
self.path.endswith('/newdm') or \
self.path.endswith('/newshare')):
New post screen
2019-07-25 21:39:09 +00:00
self._login_headers('text/html')
Save image when receiving new post
2019-07-27 20:30:58 +00:00
self.wfile.write(htmlNewPost(self.server.baseDir,self.path).encode())
New post screen
2019-07-25 21:39:09 +00:00
self.server.GETbusy=False
Start of login screen
2019-07-24 22:38:42 +00:00
return
Secondary format for individual posts
2019-07-06 21:33:46 +00:00
# get an individual post from the path /@nickname/statusnumber
if '/@' in self.path:
namedStatus=self.path.split('/@')[1]
Include port in webfinger
2019-07-19 13:32:58 +00:00
if '/' not in namedStatus:
# show actor
nickname=namedStatus
else:
Secondary format for individual posts
2019-07-06 21:33:46 +00:00
postSections=namedStatus.split('/')
if len(postSections)==2:
nickname=postSections[0]
statusNumber=postSections[1]
if len(statusNumber)>10 and statusNumber.isdigit():
Only show web interface after login
2019-07-25 16:03:58 +00:00
postFilename= \
self.server.baseDir+'/accounts/'+nickname+'@'+self.server.domain+'/outbox/'+ \
self.server.httpPrefix+':##'+self.server.domainFull+'#users#'+nickname+'#statuses#'+statusNumber+'.json'
if os.path.isfile(postFilename):
postJsonObject={}
with open(postFilename, 'r') as fp:
postJsonObject=commentjson.load(fp)
# Only authorized viewers get to see likes on posts
# Otherwize marketers could gain more social graph info
if not authorized:
if postJsonObject.get('likes'):
postJsonObject['likes']={}
if 'text/html' in self.headers['Accept']:
digest of sha256
2019-07-25 16:50:48 +00:00
self._set_headers('text/html')
Only show web interface after login
2019-07-25 16:03:58 +00:00
self.wfile.write(htmlIndividualPost(postJsonObject).encode('utf-8'))
else:
self._set_headers('application/json')
self.wfile.write(json.dumps(postJsonObject).encode('utf-8'))
self.server.GETbusy=False
return
else:
self._404()
self.server.GETbusy=False
return
Handle displaying replies
2019-07-13 19:28:14 +00:00
# get replies to a post /users/nickname/statuses/number/replies
page ending
2019-07-13 20:23:42 +00:00
if self.path.endswith('/replies') or '/replies?page=' in self.path:
Handle displaying replies
2019-07-13 19:28:14 +00:00
if '/statuses/' in self.path and '/users/' in self.path:
namedStatus=self.path.split('/users/')[1]
if '/' in namedStatus:
postSections=namedStatus.split('/')
if len(postSections)>=4:
if postSections[3].startswith('replies'):
nickname=postSections[0]
statusNumber=postSections[2]
if len(statusNumber)>10 and statusNumber.isdigit():
#get the replies file
Handle domain
2019-07-13 19:34:03 +00:00
boxname='outbox'
postDir=self.server.baseDir+'/accounts/'+nickname+'@'+self.server.domain+'/'+boxname
postRepliesFilename= \
postDir+'/'+ \
Only show web interface after login
2019-07-25 16:03:58 +00:00
self.server.httpPrefix+':##'+self.server.domainFull+'#users#'+nickname+'#statuses#'+statusNumber+'.replies'
Handle domain
2019-07-13 19:34:03 +00:00
if not os.path.isfile(postRepliesFilename):
# There are no replies, so show empty collection
repliesJson = {
'@context': 'https://www.w3.org/ns/activitystreams',
Only show web interface after login
2019-07-25 16:03:58 +00:00
'first': self.server.httpPrefix+'://'+self.server.domainFull+'/users/'+nickname+'/statuses/'+statusNumber+'/replies?page=true',
'id': self.server.httpPrefix+'://'+self.server.domainFull+'/users/'+nickname+'/statuses/'+statusNumber+'/replies',
'last': self.server.httpPrefix+'://'+self.server.domainFull+'/users/'+nickname+'/statuses/'+statusNumber+'/replies?page=true',
Handle domain
2019-07-13 19:34:03 +00:00
'totalItems': 0,
'type': 'OrderedCollection'}
Begin on a web interface
2019-07-20 21:13:36 +00:00
if 'text/html' in self.headers['Accept']:
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('text/html')
Begin on a web interface
2019-07-20 21:13:36 +00:00
self.wfile.write(htmlPostReplies(repliesJson).encode('utf-8'))
else:
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('application/json')
Begin on a web interface
2019-07-20 21:13:36 +00:00
self.wfile.write(json.dumps(repliesJson).encode('utf-8'))
Handle domain
2019-07-13 19:34:03 +00:00
self.server.GETbusy=False
return
else:
# replies exist. Itterate through the text file containing message ids
repliesJson = {
'@context': 'https://www.w3.org/ns/activitystreams',
Only show web interface after login
2019-07-25 16:03:58 +00:00
'id': self.server.httpPrefix+'://'+self.server.domainFull+'/users/'+nickname+'/statuses/'+statusNumber+'?page=true',
Handle domain
2019-07-13 19:34:03 +00:00
'orderedItems': [
],
Only show web interface after login
2019-07-25 16:03:58 +00:00
'partOf': self.server.httpPrefix+'://'+self.server.domainFull+'/users/'+nickname+'/statuses/'+statusNumber,
Handle domain
2019-07-13 19:34:03 +00:00
'type': 'OrderedCollectionPage'}
Retain the authorized header
2019-07-25 11:18:35 +00:00
Handle domain
2019-07-13 19:34:03 +00:00
# populate the items list with replies
repliesBoxes=['outbox','inbox']
with open(postRepliesFilename,'r') as repliesFile:
for messageId in repliesFile:
replyFound=False
# examine inbox and outbox
for boxname in repliesBoxes:
searchFilename= \
self.server.baseDir+ \
'/accounts/'+nickname+'@'+ \
self.server.domain+'/'+ \
boxname+'/'+ \
messageId.replace('\n','').replace('/','#')+'.json'
if os.path.isfile(searchFilename):
if authorized or \
'https://www.w3.org/ns/activitystreams#Public' in open(searchFilename).read():
with open(searchFilename, 'r') as fp:
Tidying
2019-07-14 16:57:06 +00:00
postJsonObject=commentjson.load(fp)
if postJsonObject['object'].get('cc'):
Checks on public status for viewed replies
2019-07-13 20:16:07 +00:00
if authorized or \
Tidying
2019-07-14 16:57:06 +00:00
('https://www.w3.org/ns/activitystreams#Public' in postJsonObject['object']['to'] or \
'https://www.w3.org/ns/activitystreams#Public' in postJsonObject['object']['cc']):
repliesJson['orderedItems'].append(postJsonObject)
Checks on public status for viewed replies
2019-07-13 20:16:07 +00:00
replyFound=True
else:
if authorized or \
Tidying
2019-07-14 16:57:06 +00:00
'https://www.w3.org/ns/activitystreams#Public' in postJsonObject['object']['to']:
repliesJson['orderedItems'].append(postJsonObject)
Checks on public status for viewed replies
2019-07-13 20:16:07 +00:00
replyFound=True
Handle domain
2019-07-13 19:34:03 +00:00
break
# if not in either inbox or outbox then examine the shared inbox
if not replyFound:
searchFilename= \
self.server.baseDir+ \
'/accounts/inbox@'+ \
self.server.domain+'/inbox/'+ \
messageId.replace('\n','').replace('/','#')+'.json'
if os.path.isfile(searchFilename):
if authorized or \
'https://www.w3.org/ns/activitystreams#Public' in open(searchFilename).read():
# get the json of the reply and append it to the collection
with open(searchFilename, 'r') as fp:
Tidying
2019-07-14 16:57:06 +00:00
postJsonObject=commentjson.load(fp)
if postJsonObject['object'].get('cc'):
Checks on public status for viewed replies
2019-07-13 20:16:07 +00:00
if authorized or \
Tidying
2019-07-14 16:57:06 +00:00
('https://www.w3.org/ns/activitystreams#Public' in postJsonObject['object']['to'] or \
'https://www.w3.org/ns/activitystreams#Public' in postJsonObject['object']['cc']):
repliesJson['orderedItems'].append(postJsonObject)
Checks on public status for viewed replies
2019-07-13 20:16:07 +00:00
else:
if authorized or \
Tidying
2019-07-14 16:57:06 +00:00
'https://www.w3.org/ns/activitystreams#Public' in postJsonObject['object']['to']:
repliesJson['orderedItems'].append(postJsonObject)
Handle domain
2019-07-13 19:34:03 +00:00
# send the replies json
Begin on a web interface
2019-07-20 21:13:36 +00:00
if 'text/html' in self.headers['Accept']:
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('text/html')
Begin on a web interface
2019-07-20 21:13:36 +00:00
self.wfile.write(htmlPostReplies(repliesJson).encode('utf-8'))
else:
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('application/json')
Begin on a web interface
2019-07-20 21:13:36 +00:00
self.wfile.write(json.dumps(repliesJson).encode('utf-8'))
Handle domain
2019-07-13 19:34:03 +00:00
self.server.GETbusy=False
return
Handle displaying replies
2019-07-13 19:28:14 +00:00
Show roles on profile screen
2019-07-22 17:21:45 +00:00
if self.path.endswith('/roles') and '/users/' in self.path:
namedStatus=self.path.split('/users/')[1]
if '/' in namedStatus:
postSections=namedStatus.split('/')
nickname=postSections[0]
actorFilename=self.server.baseDir+'/accounts/'+nickname+'@'+self.server.domain+'.json'
if os.path.isfile(actorFilename):
with open(actorFilename, 'r') as fp:
actorJson=commentjson.load(fp)
if actorJson.get('roles'):
if 'text/html' in self.headers['Accept']:
getPerson = \
personLookup(self.server.domain,self.path.replace('/roles',''), \
self.server.baseDir)
Show skills on profile screen
2019-07-22 20:01:46 +00:00
if getPerson:
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('text/html')
Show roles on profile screen
2019-07-22 17:21:45 +00:00
self.wfile.write(htmlProfile(self.server.baseDir, \
self.server.httpPrefix, \
True, \
self.server.ocapAlways, \
getPerson,'roles', \
self.server.session, \
self.server.cachedWebfingers, \
self.server.personCache, \
actorJson['roles']).encode('utf-8'))
else:
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('application/json')
Show roles on profile screen
2019-07-22 17:21:45 +00:00
self.wfile.write(json.dumps(actorJson['roles']).encode('utf-8'))
Show skills on profile screen
2019-07-22 20:01:46 +00:00
self.server.GETbusy=False
Show roles on profile screen
2019-07-22 17:21:45 +00:00
return
Show skills on profile screen
2019-07-22 20:01:46 +00:00
if self.path.endswith('/skills') and '/users/' in self.path:
namedStatus=self.path.split('/users/')[1]
if '/' in namedStatus:
postSections=namedStatus.split('/')
nickname=postSections[0]
actorFilename=self.server.baseDir+'/accounts/'+nickname+'@'+self.server.domain+'.json'
if os.path.isfile(actorFilename):
with open(actorFilename, 'r') as fp:
actorJson=commentjson.load(fp)
if actorJson.get('skills'):
if 'text/html' in self.headers['Accept']:
getPerson = \
personLookup(self.server.domain,self.path.replace('/skills',''), \
self.server.baseDir)
if getPerson:
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('text/html')
Show skills on profile screen
2019-07-22 20:01:46 +00:00
self.wfile.write(htmlProfile(self.server.baseDir, \
self.server.httpPrefix, \
True, \
self.server.ocapAlways, \
getPerson,'skills', \
self.server.session, \
self.server.cachedWebfingers, \
self.server.personCache, \
actorJson['skills']).encode('utf-8'))
else:
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('application/json')
Show skills on profile screen
2019-07-22 20:01:46 +00:00
self.wfile.write(json.dumps(actorJson['skills']).encode('utf-8'))
self.server.GETbusy=False
return
Secondary format for individual posts
2019-07-06 21:33:46 +00:00
# get an individual post from the path /users/nickname/statuses/number
GET individual posts
2019-07-06 21:24:47 +00:00
if '/statuses/' in self.path and '/users/' in self.path:
namedStatus=self.path.split('/users/')[1]
if '/' in namedStatus:
postSections=namedStatus.split('/')
Handle displaying replies
2019-07-13 19:28:14 +00:00
if len(postSections)>=3:
GET individual posts
2019-07-06 21:24:47 +00:00
nickname=postSections[0]
statusNumber=postSections[2]
Secondary format for individual posts
2019-07-06 21:33:46 +00:00
if len(statusNumber)>10 and statusNumber.isdigit():
Show roles on profile screen
2019-07-22 17:21:45 +00:00
postFilename= \
self.server.baseDir+'/accounts/'+nickname+'@'+self.server.domain+'/outbox/'+ \
Only show web interface after login
2019-07-25 16:03:58 +00:00
self.server.httpPrefix+':##'+self.server.domainFull+'#users#'+nickname+'#statuses#'+statusNumber+'.json'
Show roles on profile screen
2019-07-22 17:21:45 +00:00
if os.path.isfile(postFilename):
postJsonObject={}
with open(postFilename, 'r') as fp:
postJsonObject=commentjson.load(fp)
# Only authorized viewers get to see likes on posts
# Otherwize marketers could gain more social graph info
Retain the authorized header
2019-07-25 11:18:35 +00:00
if not authorized:
Show roles on profile screen
2019-07-22 17:21:45 +00:00
if postJsonObject.get('likes'):
postJsonObject['likes']={}
if 'text/html' in self.headers['Accept']:
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('text/html')
Show roles on profile screen
2019-07-22 17:21:45 +00:00
self.wfile.write(htmlIndividualPost(postJsonObject).encode('utf-8'))
else:
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('application/json')
Show roles on profile screen
2019-07-22 17:21:45 +00:00
self.wfile.write(json.dumps(postJsonObject).encode('utf-8'))
self.server.GETbusy=False
return
else:
self._404()
self.server.GETbusy=False
return
Authorization for inbox access
2019-07-03 19:32:07 +00:00
# get the inbox for a given person
if self.path.endswith('/inbox'):
if '/users/' in self.path:
Retain the authorized header
2019-07-25 11:18:35 +00:00
if authorized:
Tidying
2019-07-12 11:05:43 +00:00
inboxFeed=personBoxJson(self.server.baseDir, \
self.server.domain, \
self.server.port, \
self.path, \
self.server.httpPrefix, \
Check capabilities for shared inbox when getting inbox feed
2019-07-14 11:15:28 +00:00
maxPostsInFeed, 'inbox', \
True,self.server.ocapAlways)
Tidying
2019-07-12 11:05:43 +00:00
if inboxFeed:
Begin on a web interface
2019-07-20 21:13:36 +00:00
if 'text/html' in self.headers['Accept']:
Show timeline banner
2019-07-24 12:02:28 +00:00
nickname=self.path.replace('/users/','').replace('/inbox','')
if '?page=' in nickname:
nickname=nickname.split('?page=')[0]
Single css file
2019-07-24 11:03:56 +00:00
if 'page=' not in self.path:
# if no page was specified then show the first
inboxFeed=personBoxJson(self.server.baseDir, \
self.server.domain, \
self.server.port, \
self.path+'?page=1', \
self.server.httpPrefix, \
maxPostsInFeed, 'inbox', \
Show timeline banner
2019-07-24 12:02:28 +00:00
True,self.server.ocapAlways)
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('text/html')
Single css file
2019-07-24 11:03:56 +00:00
self.wfile.write(htmlInbox(self.server.session, \
Show timeline banner
2019-07-24 12:02:28 +00:00
self.server.baseDir, \
Single css file
2019-07-24 11:03:56 +00:00
self.server.cachedWebfingers, \
self.server.personCache, \
Show timeline banner
2019-07-24 12:02:28 +00:00
nickname, \
Single css file
2019-07-24 11:03:56 +00:00
self.server.domain, \
inboxFeed).encode('utf-8'))
Begin on a web interface
2019-07-20 21:13:36 +00:00
else:
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('application/json')
Begin on a web interface
2019-07-20 21:13:36 +00:00
self.wfile.write(json.dumps(inboxFeed).encode('utf-8'))
Tidying
2019-07-12 11:05:43 +00:00
self.server.GETbusy=False
return
else:
if self.server.debug:
print('DEBUG: '+nickname+ \
' was not authorized to access '+self.path)
Authentication debug
2019-07-04 08:56:15 +00:00
if self.server.debug:
print('DEBUG: GET access to inbox is unauthorized')
method not allowed
2019-07-03 20:32:30 +00:00
self.send_response(405)
self.end_headers()
self.server.POSTbusy=False
return
Authorization for inbox access
2019-07-03 19:32:07 +00:00
GET on outbox
2019-06-29 14:35:26 +00:00
# get outbox feed for a person
Generic in/outbox functions
2019-07-04 16:24:23 +00:00
outboxFeed=personBoxJson(self.server.baseDir,self.server.domain, \
self.server.port,self.path, \
self.server.httpPrefix, \
Don't show likes to unauthorized viewers
2019-07-12 11:20:59 +00:00
maxPostsInFeed, 'outbox', \
Retain the authorized header
2019-07-25 11:18:35 +00:00
authorized, \
Check capabilities for shared inbox when getting inbox feed
2019-07-14 11:15:28 +00:00
self.server.ocapAlways)
Combine
2019-06-29 14:41:23 +00:00
if outboxFeed:
Begin on a web interface
2019-07-20 21:13:36 +00:00
if 'text/html' in self.headers['Accept']:
Show timeline banner
2019-07-24 12:02:28 +00:00
nickname=self.path.replace('/users/','').replace('/outbox','')
if '?page=' in nickname:
nickname=nickname.split('?page=')[0]
Single css file
2019-07-24 11:03:56 +00:00
if 'page=' not in self.path:
# if a page wasn't specified then show the first one
outboxFeed=personBoxJson(self.server.baseDir,self.server.domain, \
self.server.port,self.path+'?page=1', \
self.server.httpPrefix, \
maxPostsInFeed, 'outbox', \
Retain the authorized header
2019-07-25 11:18:35 +00:00
authorized, \
Single css file
2019-07-24 11:03:56 +00:00
self.server.ocapAlways)
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('text/html')
Single css file
2019-07-24 11:03:56 +00:00
self.wfile.write(htmlOutbox(self.server.session, \
Show timeline banner
2019-07-24 12:02:28 +00:00
self.server.baseDir, \
Single css file
2019-07-24 11:03:56 +00:00
self.server.cachedWebfingers, \
self.server.personCache, \
Show timeline banner
2019-07-24 12:02:28 +00:00
nickname, \
Single css file
2019-07-24 11:03:56 +00:00
self.server.domain, \
outboxFeed).encode('utf-8'))
Begin on a web interface
2019-07-20 21:13:36 +00:00
else:
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('application/json')
Begin on a web interface
2019-07-20 21:13:36 +00:00
self.wfile.write(json.dumps(outboxFeed).encode('utf-8'))
Fallbacks for GET and POST locking
2019-07-01 14:30:48 +00:00
self.server.GETbusy=False
Following and followers feeds
2019-06-29 20:21:37 +00:00
return
Functions for shared items
2019-07-23 12:33:09 +00:00
Showing shares on profile screen
2019-07-24 09:53:07 +00:00
shares=getSharesFeedForPerson(self.server.baseDir, \
self.server.domain, \
Functions for shared items
2019-07-23 12:33:09 +00:00
self.server.port,self.path, \
self.server.httpPrefix, \
sharesPerPage)
if shares:
if 'text/html' in self.headers['Accept']:
if 'page=' not in self.path:
# get a page of shares, not the summary
shares=getSharesFeedForPerson(self.server.baseDir,self.server.domain, \
self.server.port,self.path+'?page=true', \
self.server.httpPrefix, \
sharesPerPage)
getPerson = personLookup(self.server.domain,self.path.replace('/shares',''), \
self.server.baseDir)
if getPerson:
if not self.server.session:
if self.server.debug:
print('DEBUG: creating new session')
self.server.session= \
createSession(self.server.domain,self.server.port,self.server.useTor)
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('text/html')
Functions for shared items
2019-07-23 12:33:09 +00:00
self.wfile.write(htmlProfile(self.server.baseDir, \
self.server.httpPrefix, \
authorized, \
self.server.ocapAlways, \
getPerson,'shares', \
self.server.session, \
self.server.cachedWebfingers, \
self.server.personCache, \
shares).encode('utf-8'))
self.server.GETbusy=False
return
else:
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('application/json')
Functions for shared items
2019-07-23 12:33:09 +00:00
self.wfile.write(json.dumps(shares).encode('utf-8'))
self.server.GETbusy=False
return
Tidying
2019-07-02 20:54:22 +00:00
following=getFollowingFeed(self.server.baseDir,self.server.domain, \
self.server.port,self.path, \
More generic profile page
2019-07-22 09:38:02 +00:00
self.server.httpPrefix, \
Only show a limited subset of follows/followers to unauthorized viewers
2019-07-19 08:40:51 +00:00
authorized,followsPerPage)
Following and followers feeds
2019-06-29 20:21:37 +00:00
if following:
Begin on a web interface
2019-07-20 21:13:36 +00:00
if 'text/html' in self.headers['Accept']:
More generic profile page
2019-07-22 09:38:02 +00:00
if 'page=' not in self.path:
# get a page of following, not the summary
following=getFollowingFeed(self.server.baseDir,self.server.domain, \
Followers and following on profile screen
2019-07-22 11:44:31 +00:00
self.server.port,self.path+'?page=true', \
More generic profile page
2019-07-22 09:38:02 +00:00
self.server.httpPrefix, \
authorized,followsPerPage)
getPerson = personLookup(self.server.domain,self.path.replace('/following',''), \
self.server.baseDir)
if getPerson:
Look up avatars for profile screen
2019-07-22 14:09:21 +00:00
if not self.server.session:
if self.server.debug:
print('DEBUG: creating new session')
self.server.session= \
createSession(self.server.domain,self.server.port,self.server.useTor)
Functions for shared items
2019-07-23 12:33:09 +00:00
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('text/html')
More generic profile page
2019-07-22 09:38:02 +00:00
self.wfile.write(htmlProfile(self.server.baseDir, \
self.server.httpPrefix, \
authorized, \
self.server.ocapAlways, \
getPerson,'following', \
Look up avatars for profile screen
2019-07-22 14:09:21 +00:00
self.server.session, \
self.server.cachedWebfingers, \
self.server.personCache, \
More generic profile page
2019-07-22 09:38:02 +00:00
following).encode('utf-8'))
self.server.GETbusy=False
return
Begin on a web interface
2019-07-20 21:13:36 +00:00
else:
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('application/json')
Begin on a web interface
2019-07-20 21:13:36 +00:00
self.wfile.write(json.dumps(following).encode('utf-8'))
More generic profile page
2019-07-22 09:38:02 +00:00
self.server.GETbusy=False
Followers and following on profile screen
2019-07-22 11:44:31 +00:00
return
Tidying
2019-07-02 20:54:22 +00:00
followers=getFollowingFeed(self.server.baseDir,self.server.domain, \
self.server.port,self.path, \
Reduce some line lengths
2019-07-06 17:00:22 +00:00
self.server.httpPrefix, \
Only show a limited subset of follows/followers to unauthorized viewers
2019-07-19 08:40:51 +00:00
authorized,followsPerPage,'followers')
Following and followers feeds
2019-06-29 20:21:37 +00:00
if followers:
Begin on a web interface
2019-07-20 21:13:36 +00:00
if 'text/html' in self.headers['Accept']:
More generic profile page
2019-07-22 09:38:02 +00:00
if 'page=' not in self.path:
# get a page of followers, not the summary
followers=getFollowingFeed(self.server.baseDir,self.server.domain, \
self.server.port,self.path+'?page=1', \
self.server.httpPrefix, \
authorized,followsPerPage,'followers')
getPerson = personLookup(self.server.domain,self.path.replace('/followers',''), \
self.server.baseDir)
if getPerson:
Look up avatars for profile screen
2019-07-22 14:09:21 +00:00
if not self.server.session:
if self.server.debug:
print('DEBUG: creating new session')
self.server.session= \
createSession(self.server.domain,self.server.port,self.server.useTor)
Remove extra variable
2019-07-25 14:38:51 +00:00
self._set_headers('text/html')
More generic profile page
2019-07-22 09:38:02 +00:00
self.wfile.write(htmlProfile(self.server.baseDir, \
self.server.httpPrefix, \
authorized, \
self.server.ocapAlways, \
getPerson,'followers', \
Look up avatars for profile screen
2019-07-22 14:09:21 +00:00
self.server.session, \
self.server.cachedWebfingers, \
self.server.personCache, \
More generic profile page
2019-07-22 09:38:02 +00:00
followers).encode('utf-8'))
self.server.GETbusy=False
return
Begin on a web interface
2019-07-20 21:13:36 +00:00
else:
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('application/json')
Begin on a web interface
2019-07-20 21:13:36 +00:00
self.wfile.write(json.dumps(followers).encode('utf-8'))
Fallbacks for GET and POST locking
2019-07-01 14:30:48 +00:00
self.server.GETbusy=False
Fixing public key lookup
2019-07-04 14:36:29 +00:00
return
Initial
2019-06-28 18:55:29 +00:00
# look up a person
Tidying
2019-07-02 20:54:22 +00:00
getPerson = personLookup(self.server.domain,self.path, \
self.server.baseDir)
Initial
2019-06-28 18:55:29 +00:00
if getPerson:
Begin on a web interface
2019-07-20 21:13:36 +00:00
if 'text/html' in self.headers['Accept']:
Look up avatars for profile screen
2019-07-22 14:09:21 +00:00
if not self.server.session:
if self.server.debug:
print('DEBUG: creating new session')
self.server.session= \
createSession(self.server.domain,self.server.port,self.server.useTor)
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('text/html')
Showing posts on profile
2019-07-21 22:38:44 +00:00
self.wfile.write(htmlProfile(self.server.baseDir, \
self.server.httpPrefix, \
authorized, \
self.server.ocapAlways, \
Look up avatars for profile screen
2019-07-22 14:09:21 +00:00
getPerson,'posts',
self.server.session, \
self.server.cachedWebfingers, \
self.server.personCache).encode('utf-8'))
Begin on a web interface
2019-07-20 21:13:36 +00:00
else:
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('application/json')
Begin on a web interface
2019-07-20 21:13:36 +00:00
self.wfile.write(json.dumps(getPerson).encode('utf-8'))
Fallbacks for GET and POST locking
2019-07-01 14:30:48 +00:00
self.server.GETbusy=False
Initial
2019-06-28 18:55:29 +00:00
return
# check that a json file was requested
if not self.path.endswith('.json'):
Debug option
2019-07-03 16:14:45 +00:00
if self.server.debug:
print('DEBUG: GET Not json: '+self.path+' '+self.server.baseDir)
Initial
2019-06-28 18:55:29 +00:00
self._404()
Fallbacks for GET and POST locking
2019-07-01 14:30:48 +00:00
self.server.GETbusy=False
Initial
2019-06-28 18:55:29 +00:00
return
# check that the file exists
baseDir as parameter
2019-06-30 22:56:37 +00:00
filename=self.server.baseDir+self.path
Initial
2019-06-28 18:55:29 +00:00
if os.path.isfile(filename):
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self._set_headers('application/json')
Consistent utf string
2019-07-03 19:15:42 +00:00
with open(filename, 'r', encoding='utf-8') as File:
Initial
2019-06-28 18:55:29 +00:00
content = File.read()
contentJson=json.loads(content)
Consistent utf string
2019-07-03 19:15:42 +00:00
self.wfile.write(json.dumps(contentJson).encode('utf-8'))
Initial
2019-06-28 18:55:29 +00:00
else:
Debug option
2019-07-03 16:14:45 +00:00
if self.server.debug:
print('DEBUG: GET Unknown file')
Initial
2019-06-28 18:55:29 +00:00
self._404()
Fallbacks for GET and POST locking
2019-07-01 14:30:48 +00:00
self.server.GETbusy=False
Initial
2019-06-28 18:55:29 +00:00
def do_HEAD(self):
Retain the authorized header
2019-07-25 11:18:35 +00:00
self._set_headers('application/json',None)
Test servers on different ip addresses
2019-07-01 21:01:43 +00:00
Save image when receiving new post
2019-07-27 20:30:58 +00:00
def _receiveNewPost(self,authorized: bool,postType: str) -> bool:
if authorized and '/users/' in self.path and self.path.endswith('?'+postType):
if ' boundary=' in self.headers['Content-type']:
nickname=None
nicknameStr=self.path.split('/users/')[1]
if '/' in nicknameStr:
nickname=nicknameStr.split('/')[0]
else:
return False
length = int(self.headers['Content-length'])
if length>self.server.maxPostLength:
print('POST size too large')
return False
boundary=self.headers['Content-type'].split('boundary=')[1]
if ';' in boundary:
boundary=boundary.split(';')[0]
# Note: we don't use cgi here because it's due to be deprecated
# in Python 3.8/3.10
# Instead we use the multipart mime parser from the email module
postBytes=self.rfile.read(length)
msg = email.parser.BytesParser().parsebytes(postBytes)
# why don't we just use msg.is_multipart(), rather than splitting?
# TL;DR it doesn't work for this use case because we're not using
# email style encoding message/rfc822
messageFields=msg.get_payload(decode=False).split(boundary)
fields={}
Connect new posts to web interface
2019-07-27 22:48:34 +00:00
filename=None
Save image when receiving new post
2019-07-27 20:30:58 +00:00
for f in messageFields:
Posting via web interface
2019-07-28 13:30:19 +00:00
if f=='--':
continue
Save image when receiving new post
2019-07-27 20:30:58 +00:00
if ' name="' in f:
postStr=f.split(' name="',1)[1]
if '"' in postStr:
postKey=postStr.split('"',1)[0]
postValueStr=postStr.split('"',1)[1]
if ';' not in postValueStr:
if '\r\n' in postValueStr:
postLines=postValueStr.split('\r\n')
postValue=''
if len(postLines)>2:
for line in range(2,len(postLines)-1):
if line>2:
postValue+='\n'
postValue+=postLines[line]
fields[postKey]=postValue
else:
# directly search the binary array for the beginning
# of an image
searchStr=b'Content-Type: image/png'
imageLocation=postBytes.find(searchStr)
filenameBase=self.server.baseDir+'/accounts/'+nickname+'@'+self.server.domain+'/upload'
Posting via web interface
2019-07-28 13:30:19 +00:00
if imageLocation>-1:
Save image when receiving new post
2019-07-27 20:30:58 +00:00
filename=filenameBase+'.png'
else:
searchStr=b'Content-Type: image/jpeg'
imageLocation=postBytes.find(searchStr)
Posting via web interface
2019-07-28 13:30:19 +00:00
if imageLocation>-1:
Save image when receiving new post
2019-07-27 20:30:58 +00:00
filename=filenameBase+'.jpg'
else:
searchStr=b'Content-Type: image/gif'
imageLocation=postBytes.find(searchStr)
Posting via web interface
2019-07-28 13:30:19 +00:00
if imageLocation>-1:
Save image when receiving new post
2019-07-27 20:30:58 +00:00
filename=filenameBase+'.gif'
Posting via web interface
2019-07-28 13:30:19 +00:00
if filename and imageLocation>-1:
Save image when receiving new post
2019-07-27 20:30:58 +00:00
# locate the beginning of the image, after any
# carriage returns
startPos=imageLocation+len(searchStr)
for offset in range(1,8):
if postBytes[startPos+offset]!=10:
if postBytes[startPos+offset]!=13:
startPos+=offset
break
fd = open(filename, 'wb')
fd.write(postBytes[startPos:])
fd.close()
Connect new posts to web interface
2019-07-27 22:48:34 +00:00
# send the post
if not fields.get('message'):
return False
if not fields.get('imageDescription'):
fields['imageDescription']=None
if not fields.get('subject'):
fields['subject']=None
if not fields.get('replyTo'):
fields['replyTo']=None
if postType=='newpost':
messageJson= \
createPublicPost(self.server.baseDir, \
nickname, \
self.server.domain,self.server.port, \
self.server.httpPrefix, \
fields['message'],False,False,False, \
filename,fields['imageDescription'],True, \
fields['replyTo'], fields['replyTo'],fields['subject'])
if messageJson:
Posting via web interface
2019-07-28 13:30:19 +00:00
self.postToNickname=nickname
return self._postToOutbox(messageJson)
Connect new posts to web interface
2019-07-27 22:48:34 +00:00
Handle unlisted posts
2019-07-28 11:08:14 +00:00
if postType=='newunlisted':
messageJson= \
createUnlistedPost(self.server.baseDir, \
nickname, \
self.server.domain,self.server.port, \
self.server.httpPrefix, \
fields['message'],False,False,False, \
filename,fields['imageDescription'],True, \
fields['replyTo'], fields['replyTo'],fields['subject'])
if messageJson:
Posting via web interface
2019-07-28 13:30:19 +00:00
self.postToNickname=nickname
return self._postToOutbox(messageJson)
Handle unlisted posts
2019-07-28 11:08:14 +00:00
Connect new posts to web interface
2019-07-27 22:48:34 +00:00
if postType=='newfollowers':
messageJson= \
createFollowersOnlyPost(self.server.baseDir, \
nickname, \
self.server.domain,self.server.port, \
self.server.httpPrefix, \
fields['message'],True,False,False, \
filename,fields['imageDescription'],True, \
fields['replyTo'], fields['replyTo'],fields['subject'])
if messageJson:
Posting via web interface
2019-07-28 13:30:19 +00:00
self.postToNickname=nickname
return self._postToOutbox(messageJson)
Connect new posts to web interface
2019-07-27 22:48:34 +00:00
if postType=='newdm':
messageJson= \
createDirectMessagePost(self.server.baseDir, \
nickname, \
self.server.domain,self.server.port, \
self.server.httpPrefix, \
fields['message'],True,False,False, \
filename,fields['imageDescription'],True, \
Posting via web interface
2019-07-28 13:30:19 +00:00
fields['replyTo'],fields['replyTo'],fields['subject'])
Connect new posts to web interface
2019-07-27 22:48:34 +00:00
if messageJson:
Posting via web interface
2019-07-28 13:30:19 +00:00
self.postToNickname=nickname
return self._postToOutbox(messageJson)
Connect new posts to web interface
2019-07-27 22:48:34 +00:00
if postType=='newshare':
Posting shares from the web interface
2019-07-28 08:34:49 +00:00
if not fields.get('itemType'):
return False
if not fields.get('category'):
return False
if not fields.get('location'):
return False
if not fields.get('duration'):
return False
addShare(self.server.baseDir, \
self.server.httpPrefix, \
nickname, \
self.server.domain,self.server.port, \
fields['subject'], \
fields['message'], \
filename, \
fields['itemType'], \
fields['category'], \
fields['location'], \
fields['duration'],
self.server.debug)
if os.path.isfile(filename):
os.remove(filename)
Posting via web interface
2019-07-28 13:30:19 +00:00
self.postToNickname=nickname
return self._postToOutbox(messageJson)
Save image when receiving new post
2019-07-27 20:30:58 +00:00
return False
Initial
2019-06-28 18:55:29 +00:00
def do_POST(self):
Reserved usernames
2019-07-04 17:56:25 +00:00
if self.server.debug:
Reduce some line lengths
2019-07-06 17:00:22 +00:00
print('DEBUG: POST to from '+self.server.baseDir+ \
' path: '+self.path+' busy: '+ \
str(self.server.POSTbusy))
Fallbacks for GET and POST locking
2019-07-01 14:30:48 +00:00
if self.server.POSTbusy:
currTimePOST=int(time.time())
if currTimePOST-self.server.lastPOST<10:
http busy code
2019-06-29 17:28:43 +00:00
self.send_response(429)
Simple busy state for POST
2019-06-29 17:27:32 +00:00
self.end_headers()
Fallbacks for GET and POST locking
2019-07-01 14:30:48 +00:00
return
self.server.lastPOST=currTimePOST
Debug option
2019-07-03 16:14:45 +00:00
Fallbacks for GET and POST locking
2019-07-01 14:30:48 +00:00
self.server.POSTbusy=True
Debugging POST
2019-07-01 11:48:54 +00:00
if not self.headers.get('Content-type'):
Debug option
2019-07-03 16:14:45 +00:00
print('Content-type header missing')
Debugging POST
2019-07-01 11:48:54 +00:00
self.send_response(400)
self.end_headers()
Fallbacks for GET and POST locking
2019-07-01 14:30:48 +00:00
self.server.POSTbusy=False
Debugging POST
2019-07-01 11:48:54 +00:00
return
Debug option
2019-07-03 16:14:45 +00:00
create wrapping
2019-07-03 21:37:46 +00:00
# remove any trailing slashes from the path
Upload of shared item images
2019-07-23 19:02:26 +00:00
self.path=self.path.replace('/outbox/','/outbox').replace('/inbox/','/inbox').replace('/shares/','/shares').replace('/sharedInbox/','/sharedInbox')
create wrapping
2019-07-03 21:37:46 +00:00
Save image when receiving new post
2019-07-27 20:30:58 +00:00
# check authorization
authorized = self._isAuthorized()
if authorized:
if self.server.debug:
print('POST Authorization granted')
else:
if self.server.debug:
print('POST Not authorized')
create wrapping
2019-07-03 21:37:46 +00:00
# if this is a POST to teh outbox then check authentication
self.outboxAuthenticated=False
self.postToNickname=None
Start of login screen
2019-07-24 22:38:42 +00:00
if self.path.startswith('/login'):
Login screen redirects
2019-07-25 10:56:24 +00:00
# get the contents of POST containing login credentials
length = int(self.headers['Content-length'])
if length>512:
print('Login failed - credentials too long')
self.send_response(401)
self.end_headers()
self.server.POSTbusy=False
return
loginParams=self.rfile.read(length).decode('utf-8')
loginNickname,loginPassword=htmlGetLoginCredentials(loginParams,self.server.lastLoginTime)
Start of login screen
2019-07-24 22:38:42 +00:00
if loginNickname:
self.server.lastLoginTime=int(time.time())
authHeader=createBasicAuthHeader(loginNickname,loginPassword)
if not authorizeBasic(self.server.baseDir,'/users/'+loginNickname+'/outbox',authHeader,False):
Login screen redirects
2019-07-25 10:56:24 +00:00
print('Login failed: '+loginNickname)
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
# remove any token
if self.server.tokens.get(loginNickname):
del self.server.tokensLookup[self.server.tokens[loginNickname]]
del self.server.tokens[loginNickname]
del self.server.salts[loginNickname]
Login text
2019-07-25 19:22:19 +00:00
self.send_response(303)
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self.send_header('Content-type', 'text/html; charset=utf-8')
self.send_header('Set-Cookie', 'epicyon=; SameSite=Strict')
Login text
2019-07-25 19:22:19 +00:00
self.send_header('Location', '/login')
self.end_headers()
Start of login screen
2019-07-24 22:38:42 +00:00
self.server.POSTbusy=False
return
Login screen redirects
2019-07-25 10:56:24 +00:00
else:
# login success - redirect with authorization
print('Login success: '+loginNickname)
self.send_response(303)
Notes
2019-07-25 14:30:12 +00:00
# This produces a deterministic token based on nick+password+salt
# But notice that the salt is ephemeral, so a server reboot changes them.
# This allows you to be logged in on two or more devices with the
# same token, but also ensures that if an adversary obtains the token
# then rebooting the server is sufficient to thwart them, without
# any password changes.
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
if not self.server.salts.get(loginNickname):
self.server.salts[loginNickname]=createPassword(32)
digest of sha256
2019-07-25 16:50:48 +00:00
self.server.tokens[loginNickname]=sha256((loginNickname+loginPassword+self.server.salts[loginNickname]).encode('utf-8')).hexdigest()
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
self.server.tokensLookup[self.server.tokens[loginNickname]]=loginNickname
self.send_header('Set-Cookie', 'epicyon='+self.server.tokens[loginNickname]+'; SameSite=Strict')
Go to inbox by default
2019-07-25 19:23:52 +00:00
self.send_header('Location', '/users/'+loginNickname+'/inbox')
Login screen redirects
2019-07-25 10:56:24 +00:00
self.end_headers()
self.server.POSTbusy=False
return
Start of login screen
2019-07-24 22:38:42 +00:00
self.send_response(200)
self.end_headers()
self.server.POSTbusy=False
return
Save image when receiving new post
2019-07-27 20:30:58 +00:00
if self._receiveNewPost(authorized,'newpost'):
Redirect after post
2019-07-28 14:09:48 +00:00
self._redirect_headers('/users/'+self.postToNickname+'/outbox')
Save image when receiving new post
2019-07-27 20:30:58 +00:00
self.server.POSTbusy=False
return
elif self._receiveNewPost(authorized,'newunlisted'):
Redirect after post
2019-07-28 14:09:48 +00:00
self._redirect_headers('/users/'+self.postToNickname+'/outbox')
Save image when receiving new post
2019-07-27 20:30:58 +00:00
self.server.POSTbusy=False
return
elif self._receiveNewPost(authorized,'newfollowers'):
Redirect after post
2019-07-28 14:09:48 +00:00
self._redirect_headers('/users/'+self.postToNickname+'/outbox')
Save image when receiving new post
2019-07-27 20:30:58 +00:00
self.server.POSTbusy=False
return
elif self._receiveNewPost(authorized,'newdm'):
Redirect after post
2019-07-28 14:09:48 +00:00
self._redirect_headers('/users/'+self.postToNickname+'/outbox')
Save image when receiving new post
2019-07-27 20:30:58 +00:00
self.server.POSTbusy=False
return
elif self._receiveNewPost(authorized,'newshare'):
Redirect after post
2019-07-28 14:09:48 +00:00
self._redirect_headers('/users/'+self.postToNickname+'/shares')
Save image when receiving new post
2019-07-27 20:30:58 +00:00
self.server.POSTbusy=False
return
Upload of shared item images
2019-07-23 19:02:26 +00:00
if self.path.endswith('/outbox') or self.path.endswith('/shares'):
Outbox post authorization is on particular nicknames
2019-07-03 20:03:38 +00:00
if '/users/' in self.path:
Save image when receiving new post
2019-07-27 20:30:58 +00:00
if authorized:
Tidying
2019-07-12 11:05:43 +00:00
self.outboxAuthenticated=True
Fixing c2s
2019-07-16 10:19:04 +00:00
pathUsersSection=self.path.split('/users/')[1]
Tidying
2019-07-12 11:05:43 +00:00
self.postToNickname=pathUsersSection.split('/')[0]
create wrapping
2019-07-03 21:37:46 +00:00
if not self.outboxAuthenticated:
self.send_response(405)
self.end_headers()
self.server.POSTbusy=False
return
Debug option
2019-07-03 16:14:45 +00:00
# check that the post is to an expected path
Prepare for shared inbox
2019-07-05 10:21:10 +00:00
if not (self.path.endswith('/outbox') or \
self.path.endswith('/inbox') or \
Upload of shared item images
2019-07-23 19:02:26 +00:00
self.path.endswith('/shares') or \
Add a capabilities account to sign requests
2019-07-05 21:24:16 +00:00
self.path.endswith('/caps/new') or \
Prepare for shared inbox
2019-07-05 10:21:10 +00:00
self.path=='/sharedInbox'):
Debug option
2019-07-03 16:14:45 +00:00
print('Attempt to POST to invalid path '+self.path)
self.send_response(400)
self.end_headers()
self.server.POSTbusy=False
return
Initial
2019-06-28 18:55:29 +00:00
# read the message and convert it into a python dictionary
Debugging POST
2019-07-01 11:48:54 +00:00
length = int(self.headers['Content-length'])
Debug option
2019-07-03 16:14:45 +00:00
if self.server.debug:
print('DEBUG: content-length: '+str(length))
Uploading images via c2s
2019-07-16 14:23:06 +00:00
if not self.headers['Content-type'].startswith('image/'):
if length>self.server.maxMessageLength:
More debug
2019-07-19 15:22:04 +00:00
print('Maximum message length exceeded '+str(length))
Uploading images via c2s
2019-07-16 14:23:06 +00:00
self.send_response(400)
self.end_headers()
self.server.POSTbusy=False
return
else:
if length>self.server.maxImageSize:
More debug
2019-07-19 15:22:04 +00:00
print('Maximum image size exceeded '+str(length))
Uploading images via c2s
2019-07-16 14:23:06 +00:00
self.send_response(400)
self.end_headers()
self.server.POSTbusy=False
return
# receive images to the outbox
if self.headers['Content-type'].startswith('image/') and \
'/users/' in self.path:
if not self.outboxAuthenticated:
if self.server.debug:
print('DEBUG: unathenticated attempt to post image to outbox')
self.send_response(403)
self.end_headers()
self.server.POSTbusy=False
return
pathUsersSection=self.path.split('/users/')[1]
if '/' not in pathUsersSection:
self.send_response(404)
self.end_headers()
self.server.POSTbusy=False
return
self.postFromNickname=pathUsersSection.split('/')[0]
accountsDir=self.server.baseDir+'/accounts/'+self.postFromNickname+'@'+self.server.domain
if not os.path.isdir(accountsDir):
self.send_response(404)
self.end_headers()
self.server.POSTbusy=False
return
mediaBytes=self.rfile.read(length)
mediaFilenameBase=accountsDir+'/upload'
mediaFilename=mediaFilenameBase+'.png'
if self.headers['Content-type'].endswith('jpeg'):
mediaFilename=mediaFilenameBase+'.jpg'
if self.headers['Content-type'].endswith('gif'):
mediaFilename=mediaFilenameBase+'.gif'
with open(mediaFilename, 'wb') as avFile:
avFile.write(mediaBytes)
if self.server.debug:
print('DEBUG: image saved to '+mediaFilename)
self.send_response(201)
self.end_headers()
self.server.POSTbusy=False
return
# refuse to receive non-json content
if self.headers['Content-type'] != 'application/json':
print("POST is not json: "+self.headers['Content-type'])
reject giant messages
2019-06-28 21:06:05 +00:00
self.send_response(400)
self.end_headers()
Fallbacks for GET and POST locking
2019-07-01 14:30:48 +00:00
self.server.POSTbusy=False
reject giant messages
2019-06-28 21:06:05 +00:00
return
Debug option
2019-07-03 16:14:45 +00:00
if self.server.debug:
print('DEBUG: Reading message')
Debugging POST
2019-07-01 11:48:54 +00:00
messageBytes=self.rfile.read(length)
Uploading images via c2s
2019-07-16 14:23:06 +00:00
messageJson=json.loads(messageBytes)
Fix ports on post filenames
2019-07-18 11:35:48 +00:00
create wrapping
2019-07-03 21:37:46 +00:00
# https://www.w3.org/TR/activitypub/#object-without-create
if self.outboxAuthenticated:
Fixing c2s
2019-07-16 10:19:04 +00:00
if self._postToOutbox(messageJson):
Test for announce via c2s
2019-07-16 19:07:45 +00:00
if messageJson.get('id'):
Fixing c2s
2019-07-16 10:19:04 +00:00
self.headers['Location']= \
Test for announce via c2s
2019-07-16 19:07:45 +00:00
messageJson['id'].replace('/activity','')
Client to server posts overwrite some parameters
2019-07-03 22:16:03 +00:00
self.send_response(201)
self.end_headers()
self.server.POSTbusy=False
return
else:
self.send_response(403)
self.end_headers()
self.server.POSTbusy=False
return
create wrapping
2019-07-03 21:37:46 +00:00
Check inbox items for expected params
2019-07-02 15:07:27 +00:00
# check the necessary properties are available
Debug option
2019-07-03 16:14:45 +00:00
if self.server.debug:
print('DEBUG: Check message has params')
Shared inbox may be named 'inbox'
2019-07-05 15:10:21 +00:00
if self.path.endswith('/inbox') or \
self.path=='/sharedInbox':
create wrapping
2019-07-03 21:37:46 +00:00
if not inboxMessageHasParams(messageJson):
Test for follow request
2019-07-06 13:49:25 +00:00
if self.server.debug:
Fixing c2s
2019-07-16 10:19:04 +00:00
pprint(messageJson)
Test for follow request
2019-07-06 13:49:25 +00:00
print("DEBUG: inbox message doesn't have the required parameters")
create wrapping
2019-07-03 21:37:46 +00:00
self.send_response(403)
self.end_headers()
self.server.POSTbusy=False
return
Check inbox items for expected params
2019-07-02 15:07:27 +00:00
Reduce some line lengths
2019-07-06 17:00:22 +00:00
if not inboxPermittedMessage(self.server.domain, \
messageJson, \
Updating of capabilities
2019-07-09 14:20:23 +00:00
self.server.federationList):
Debug option
2019-07-03 16:14:45 +00:00
if self.server.debug:
Move shared inbox posts to people who follow
2019-07-05 13:26:54 +00:00
# https://www.youtube.com/watch?v=K3PrSj9XEu4
Debug option
2019-07-03 16:14:45 +00:00
print('DEBUG: Ah Ah Ah')
inbox functions
2019-06-28 21:59:54 +00:00
self.send_response(403)
self.end_headers()
Fallbacks for GET and POST locking
2019-07-01 14:30:48 +00:00
self.server.POSTbusy=False
Debugging POST
2019-07-01 11:48:54 +00:00
return
Fallbacks for GET and POST locking
2019-07-01 14:30:48 +00:00
Prepare for shared inbox
2019-07-05 10:21:10 +00:00
if self.server.debug:
pprint(messageJson)
Dependencies
2019-07-02 17:11:59 +00:00
Fixing public key lookup
2019-07-04 14:36:29 +00:00
if not self.headers.get('signature'):
if 'keyId=' not in self.headers['signature']:
if self.server.debug:
print('DEBUG: POST to inbox has no keyId in header signature parameter')
self.send_response(403)
self.end_headers()
self.server.POSTbusy=False
return
Save posts to inbox to a queue
2019-07-04 10:02:56 +00:00
Debug option
2019-07-03 16:14:45 +00:00
if self.server.debug:
Test for follow request
2019-07-06 13:49:25 +00:00
print('DEBUG: POST saving to inbox queue')
Save posts to inbox to a queue
2019-07-04 10:02:56 +00:00
if '/users/' in self.path:
pathUsersSection=self.path.split('/users/')[1]
if '/' not in pathUsersSection:
if self.server.debug:
print('DEBUG: This is not a users endpoint')
else:
self.postToNickname=pathUsersSection.split('/')[0]
if self.postToNickname:
Posting via web interface
2019-07-28 13:30:19 +00:00
queueStatus=self._updateInboxQueue(self.postToNickname,messageJson,False)
Limit inbox queue length
2019-07-15 12:27:26 +00:00
if queueStatus==0:
self.send_response(200)
self.end_headers()
self.server.POSTbusy=False
inbox queue
2019-07-04 12:23:53 +00:00
return
Limit inbox queue length
2019-07-15 12:27:26 +00:00
if queueStatus==1:
Service unavailable status
2019-07-15 12:28:41 +00:00
self.send_response(503)
Limit inbox queue length
2019-07-15 12:27:26 +00:00
self.end_headers()
self.server.POSTbusy=False
return
inbox queue
2019-07-04 12:23:53 +00:00
self.send_response(403)
Fallbacks for GET and POST locking
2019-07-01 14:30:48 +00:00
self.end_headers()
self.server.POSTbusy=False
return
inbox queue
2019-07-04 12:23:53 +00:00
else:
Shared inbox may be named 'inbox'
2019-07-05 15:10:21 +00:00
if self.path == '/sharedInbox' or self.path == '/inbox':
Check shared inbox path
2019-07-05 10:24:20 +00:00
print('DEBUG: POST to shared inbox')
Posting via web interface
2019-07-28 13:30:19 +00:00
queueStatus=_updateInboxQueue('inbox',messageJson,False)
Limit inbox queue length
2019-07-15 12:27:26 +00:00
if queueStatus==0:
self.send_response(200)
self.end_headers()
self.server.POSTbusy=False
Create shared inbox on start of daemon
2019-07-05 11:27:18 +00:00
return
Limit inbox queue length
2019-07-15 12:27:26 +00:00
if queueStatus==1:
Service unavailable status
2019-07-15 12:28:41 +00:00
self.send_response(503)
Limit inbox queue length
2019-07-15 12:27:26 +00:00
self.end_headers()
self.server.POSTbusy=False
return
Check shared inbox path
2019-07-05 10:24:20 +00:00
self.send_response(200)
self.end_headers()
self.server.POSTbusy=False
Debug option
2019-07-03 16:14:45 +00:00
Tidying
2019-07-13 09:37:17 +00:00
def runDaemon(clientToServer: bool,baseDir: str,domain: str, \
port=80,httpPrefix='https', \
Etra default capabilities
2019-07-09 18:11:23 +00:00
fedList=[],noreply=False,nolike=False,nopics=False, \
noannounce=False,cw=False,ocapAlways=False, \
Add quotas
2019-07-15 10:22:19 +00:00
useTor=False,maxReplies=64, \
Make initial quotas high - one every ten seconds
2019-07-15 10:27:53 +00:00
domainMaxPostsPerDay=8640,accountMaxPostsPerDay=8640, \
Don't allow federated deletes by default
2019-07-17 18:13:45 +00:00
allowDeletion=False,debug=False) -> None:
Initial
2019-06-28 18:55:29 +00:00
if len(domain)==0:
Tests for follow functions
2019-07-03 09:24:55 +00:00
domain='localhost'
Initial
2019-06-28 18:55:29 +00:00
if '.' not in domain:
Allow localhost as domain
2019-07-03 12:24:54 +00:00
if domain != 'localhost':
print('Invalid domain: ' + domain)
return
Initial
2019-06-28 18:55:29 +00:00
Tests for follow functions
2019-07-03 09:24:55 +00:00
serverAddress = ('', port)
Test servers on different ip addresses
2019-07-01 21:01:43 +00:00
httpd = ThreadingHTTPServer(serverAddress, PubServer)
Save image when receiving new post
2019-07-27 20:30:58 +00:00
# max POST size of 10M
httpd.maxPostLength=1024*1024*10
Tidying of daemon globals
2019-06-30 20:03:23 +00:00
httpd.domain=domain
httpd.port=port
Include host in headers
2019-07-25 09:13:02 +00:00
httpd.domainFull=domain
if port!=80 and port!=443:
httpd.domainFull=domain+':'+str(port)
Option to use dat urls
2019-07-03 19:00:03 +00:00
httpd.httpPrefix=httpPrefix
Debug option
2019-07-03 16:14:45 +00:00
httpd.debug=debug
Tidying of daemon globals
2019-06-30 20:03:23 +00:00
httpd.federationList=fedList.copy()
Fix network test
2019-07-04 20:25:19 +00:00
httpd.baseDir=baseDir
Fallbacks for GET and POST locking
2019-07-01 14:30:48 +00:00
httpd.personCache={}
httpd.cachedWebfingers={}
httpd.useTor=useTor
Dependencies
2019-07-02 17:11:59 +00:00
httpd.session = None
httpd.sessionLastUpdate=0
Fallbacks for GET and POST locking
2019-07-01 14:30:48 +00:00
httpd.lastGET=0
httpd.lastPOST=0
httpd.GETbusy=False
httpd.POSTbusy=False
Test servers on different ip addresses
2019-07-01 21:01:43 +00:00
httpd.receivedMessage=False
Save posts to inbox to a queue
2019-07-04 10:02:56 +00:00
httpd.inboxQueue=[]
Send accept message after follow
2019-07-05 18:57:19 +00:00
httpd.sendThreads=[]
httpd.postLog=[]
Limit inbox queue length
2019-07-15 12:27:26 +00:00
httpd.maxQueueLength=16
Option to strictly enforce object capabilities
2019-07-07 17:47:37 +00:00
httpd.ocapAlways=ocapAlways
Uploading images via c2s
2019-07-16 14:23:06 +00:00
httpd.maxMessageLength=5000
httpd.maxImageSize=10*1024*1024
Allow deletes in tests
2019-07-17 19:31:52 +00:00
httpd.allowDeletion=allowDeletion
Start of login screen
2019-07-24 22:38:42 +00:00
httpd.lastLoginTime=0
Deterministic tokens so that logins from multiple devices are possible
2019-07-25 14:24:42 +00:00
httpd.salts={}
httpd.tokens={}
httpd.tokensLookup={}
Set default capabilities with options
2019-07-09 17:54:08 +00:00
httpd.acceptedCaps=["inbox:write","objects:read"]
if noreply:
httpd.acceptedCaps.append('inbox:noreply')
if nolike:
httpd.acceptedCaps.append('inbox:nolike')
Etra default capabilities
2019-07-09 18:11:23 +00:00
if nopics:
httpd.acceptedCaps.append('inbox:nopics')
if noannounce:
httpd.acceptedCaps.append('inbox:noannounce')
if cw:
httpd.acceptedCaps.append('inbox:cw')
Move shared inbox account into daemon
2019-07-11 12:29:31 +00:00
First account gets admin status
2019-07-18 13:10:26 +00:00
if not os.path.isdir(baseDir+'/accounts/inbox@'+domain):
print('Creating shared inbox: inbox@'+domain)
createSharedInbox(baseDir,'inbox',domain,port,httpPrefix)
Slightly more verbose
2019-07-12 09:52:06 +00:00
print('Creating inbox queue')
Reduce some line lengths
2019-07-06 17:00:22 +00:00
httpd.thrInboxQueue= \
threadWithTrace(target=runInboxQueue, \
args=(baseDir,httpPrefix,httpd.sendThreads, \
httpd.postLog,httpd.cachedWebfingers, \
httpd.personCache,httpd.inboxQueue, \
domain,port,useTor,httpd.federationList, \
Maximum replies per post
2019-07-13 21:00:12 +00:00
httpd.ocapAlways,maxReplies, \
Add quotas
2019-07-15 10:22:19 +00:00
domainMaxPostsPerDay,accountMaxPostsPerDay, \
Don't allow federated deletes by default
2019-07-17 18:13:45 +00:00
allowDeletion,debug,httpd.acceptedCaps),daemon=True)
inbox queue
2019-07-04 12:23:53 +00:00
httpd.thrInboxQueue.start()
Tidying
2019-07-13 09:37:17 +00:00
if clientToServer:
print('Running ActivityPub client on ' + domain + ' port ' + str(port))
else:
print('Running ActivityPub server on ' + domain + ' port ' + str(port))
Initial
2019-06-28 18:55:29 +00:00
httpd.serve_forever()