__filename__ = "daemon.py"
__author__ = "Bob Mottram"
__license__ = "AGPL3+"
__version__ = "1.1.0"
__maintainer__ = "Bob Mottram"
__email__ = "bob@freedombone.net"
__status__ = "Production"
from http.server import BaseHTTPRequestHandler,ThreadingHTTPServer
#import socketserver
import json
import time
import base64
import locale
from functools import partial
# used for mime decoding of message POST
import email.parser
# for saving images
from binascii import a2b_base64
from hashlib import sha256
from hashlib import sha1
from session import createSession
from webfinger import webfingerMeta
from webfinger import webfingerNodeInfo
from webfinger import webfingerLookup
from webfinger import webfingerHandle
from metadata import metaDataNodeInfo
from metadata import metaDataInstance
from pgp import getEmailAddress
from pgp import setEmailAddress
from pgp import getPGPpubKey
from pgp import setPGPpubKey
from xmpp import getXmppAddress
from xmpp import setXmppAddress
from matrix import getMatrixAddress
from matrix import setMatrixAddress
from donate import getDonationUrl
from donate import setDonationUrl
from person import randomizeActorImages
from person import personUpgradeActor
from person import activateAccount
from person import deactivateAccount
from person import registerAccount
from person import personLookup
from person import personBoxJson
from person import createSharedInbox
from person import isSuspended
from person import suspendAccount
from person import unsuspendAccount
from person import removeAccount
from person import canRemovePost
from person import personSnooze
from person import personUnsnooze
from posts import mutePost
from posts import unmutePost
from posts import createQuestionPost
from posts import outboxMessageCreateWrap
from posts import savePostToBox
from posts import sendToFollowersThread
from posts import postIsAddressedToPublic
from posts import sendToNamedAddresses
from posts import createPublicPost
from posts import createReportPost
from posts import createUnlistedPost
from posts import createFollowersOnlyPost
from posts import createDirectMessagePost
from posts import populateRepliesJson
from posts import addToField
from posts import expireCache
from inbox import inboxPermittedMessage
from inbox import inboxMessageHasParams
from inbox import runInboxQueue
from inbox import runInboxQueueWatchdog
from inbox import savePostToInboxQueue
from inbox import populateReplies
from inbox import getPersonPubKey
from inbox import inboxUpdateIndex
from follow import getFollowingFeed
from follow import outboxUndoFollow
from follow import sendFollowRequest
from auth import authorize
from auth import createPassword
from auth import createBasicAuthHeader
from auth import authorizeBasic
from auth import storeBasicCredentials
from threads import threadWithTrace
from threads import removeDormantThreads
from media import getMediaPath
from media import createMediaDirs
from delete import outboxDelete
from like import outboxLike
from like import outboxUndoLike
from bookmarks import outboxBookmark
from bookmarks import outboxUndoBookmark
from blocking import outboxBlock
from blocking import outboxUndoBlock
from blocking import addBlock
from blocking import removeBlock
from blocking import addGlobalBlock
from blocking import removeGlobalBlock
from blocking import isBlockedHashtag
from blocking import isBlockedDomain
from config import setConfigParam
from config import getConfigParam
from roles import outboxDelegate
from roles import setRole
from roles import clearModeratorStatus
from skills import outboxSkills
from availability import outboxAvailability
from webinterface import htmlCalendarDeleteConfirm
from webinterface import htmlDeletePost
from webinterface import htmlAbout
from webinterface import htmlRemoveSharedItem
from webinterface import htmlInboxDMs
from webinterface import htmlInboxReplies
from webinterface import htmlInboxMedia
from webinterface import htmlUnblockConfirm
from webinterface import htmlPersonOptions
from webinterface import htmlIndividualPost
from webinterface import htmlProfile
from webinterface import htmlInbox
from webinterface import htmlBookmarks
from webinterface import htmlShares
from webinterface import htmlOutbox
from webinterface import htmlModeration
from webinterface import htmlPostReplies
from webinterface import htmlLogin
from webinterface import htmlSuspended
from webinterface import htmlGetLoginCredentials
from webinterface import htmlNewPost
from webinterface import htmlFollowConfirm
from webinterface import htmlCalendar
from webinterface import htmlSearch
from webinterface import htmlSearchEmoji
from webinterface import htmlSearchEmojiTextEntry
from webinterface import htmlUnfollowConfirm
from webinterface import htmlProfileAfterSearch
from webinterface import htmlEditProfile
from webinterface import htmlTermsOfService
from webinterface import htmlSkillsSearch
from webinterface import htmlHashtagSearch
from webinterface import htmlModerationInfo
from webinterface import htmlSearchSharedItems
from webinterface import htmlHashtagBlocked
from shares import getSharesFeedForPerson
from shares import outboxShareUpload
from shares import outboxUndoShareUpload
from shares import addShare
from shares import removeShare
from shares import expireShares
from utils import removeAvatarFromCache
from utils import locatePost
from utils import getCachedPostFilename
from utils import removePostFromCache
from utils import getNicknameFromActor
from utils import getDomainFromActor
from utils import getStatusNumber
from utils import urlPermitted
from utils import loadJson
from utils import saveJson
from manualapprove import manualDenyFollowRequest
from manualapprove import manualApproveFollowRequest
from announce import createAnnounce
from announce import outboxAnnounce
from content import addHtmlTags
from content import extractMediaInFormPOST
from content import saveMediaInFormPOST
from content import extractTextFieldsInPOST
from media import removeMetaData
from cache import storePersonInCache
from cache import getPersonFromCache
from httpsig import verifyPostHeaders
from theme import setTheme
from schedule import runPostSchedule
from schedule import runPostScheduleWatchdog
from schedule import removeScheduledPosts
from outbox import postMessageToOutbox
from happening import removeCalendarEvent
import os
import sys
# maximum number of posts to list in outbox feed
maxPostsInFeed=12
# reduced posts for media feed because it can take a while
maxPostsInMediaFeed=6
# number of follows/followers per page
followsPerPage=12
# number of item shares per page
sharesPerPage=12
def readFollowList(filename: str) -> None:
"""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:
nickname,domain = parseHandle(u)
if nickname:
followlist.append(nickname+'@'+domain)
followUsers.close()
return followlist
class PubServer(BaseHTTPRequestHandler):
protocol_version = 'HTTP/1.1'
def _sendReplyToQuestion(self,nickname: str,messageId: str,answer: str) -> None:
"""Sends a reply to a question
"""
votesFilename= \
self.server.baseDir+'/accounts/'+ \
nickname+'@'+self.server.domain+'/questions.txt'
if os.path.isfile(votesFilename):
# have we already voted on this?
if messageId in open(votesFilename).read():
print('Already voted on message '+messageId)
return
print('Voting on message '+messageId)
print('Vote for: '+answer)
messageJson= \
createPublicPost(self.server.baseDir, \
nickname, \
self.server.domain,self.server.port, \
self.server.httpPrefix, \
answer,False,False,False, \
None,None,None,True, \
messageId,messageId,None, \
False,None,None,None)
if messageJson:
# name field contains the answer
messageJson['object']['name']=answer
if self._postToOutbox(messageJson,__version__,nickname):
postFilename= \
locatePost(self.server.baseDir,nickname, \
self.server.domain,messageId)
if postFilename:
postJsonObject=loadJson(postFilename)
if postJsonObject:
populateReplies(self.server.baseDir, \
self.server.httpPrefix, \
self.server.domainFull, \
postJsonObject, \
self.server.maxReplies, \
self.server.debug)
# record the vote
votesFile=open(votesFilename,'a+')
if votesFile:
votesFile.write(messageId+'\n')
votesFile.close()
# ensure that the cached post is removed if it exists,
# so that it then will be recreated
cachedPostFilename= \
getCachedPostFilename(self.server.baseDir, \
nickname, \
self.server.domain, \
postJsonObject)
if cachedPostFilename:
if os.path.isfile(cachedPostFilename):
os.remove(cachedPostFilename)
# remove from memory cache
removePostFromCache(postJsonObject, \
self.server.recentPostsCache)
else:
print('ERROR: unable to post vote to outbox')
else:
print('ERROR: unable to create vote')
def _removePostInteractions(self,postJsonObject: {}) -> None:
"""Removes potentially sensitive interactions from a post
This is the type of thing which would be of interest to marketers
or of saleable value to them. eg. Knowing who likes who or what.
"""
if postJsonObject.get('likes'):
postJsonObject['likes']={'items': []}
if postJsonObject.get('shares'):
postJsonObject['shares']={}
if postJsonObject.get('replies'):
postJsonObject['replies']={}
if postJsonObject.get('bookmarks'):
postJsonObject['bookmarks']={}
if not postJsonObject.get('object'):
return
if not isinstance(postJsonObject['object'], dict):
return
if postJsonObject['object'].get('likes'):
postJsonObject['object']['likes']={'items': []}
if postJsonObject['object'].get('shares'):
postJsonObject['object']['shares']={}
if postJsonObject['object'].get('replies'):
postJsonObject['object']['replies']={}
if postJsonObject['object'].get('bookmarks'):
postJsonObject['object']['bookmarks']={}
def _requestHTTP(self) -> bool:
"""Should a http response be given?
"""
if not self.headers.get('Accept'):
return False
if self.server.debug:
print('ACCEPT: '+self.headers['Accept'])
if 'image/' in self.headers['Accept']:
if 'text/html' not in self.headers['Accept']:
return False
if 'video/' in self.headers['Accept']:
if 'text/html' not in self.headers['Accept']:
return False
if 'audio/' in self.headers['Accept']:
if 'text/html' not in self.headers['Accept']:
return False
if self.headers['Accept'].startswith('*'):
return False
if 'json' in self.headers['Accept']:
return False
return True
def _fetchAuthenticated(self) -> bool:
"""http authentication of GET requests for json
"""
if not self.server.authenticatedFetch:
return True
# check that the headers are signed
if not self.headers.get('signature'):
if self.server.debug:
print('WARN: authenticated fetch, GET has no signature in headers')
return False
# get the keyId
keyId=None
signatureParams=self.headers['signature'].split(',')
for signatureItem in signatureParams:
if signatureItem.startswith('keyId='):
if '"' in signatureItem:
keyId=signatureItem.split('"')[1]
break
if not keyId:
if self.server.debug:
print('WARN: authenticated fetch, failed to obtain keyId from signature')
return False
# is the keyId (actor) valid?
if not urlPermitted(keyId,self.server.federationList,"inbox:read"):
if self.server.debug:
print('Authorized fetch failed: '+keyId+' is not permitted')
return False
# make sure we have a session
if not self.server.session:
if self.server.debug:
print('DEBUG: creating new session during authenticated fetch')
self.server.session= \
createSession(self.server.useTor)
# obtain the public key
pubKey= \
getPersonPubKey(self.server.baseDir,self.server.session,keyId, \
self.server.personCache,self.server.debug, \
__version__,self.server.httpPrefix, \
self.server.domain)
if not pubKey:
if self.server.debug:
print('DEBUG: Authenticated fetch failed to obtain public key for '+ \
keyId)
return False
# it is assumed that there will be no message body on authenticated fetches
# and also consequently no digest
GETrequestBody=''
GETrequestDigest=None
# verify the GET request without any digest
if verifyPostHeaders(self.server.httpPrefix, \
pubKey,self.headers, \
self.path,True, \
GETrequestDigest, \
GETrequestBody,debug):
return True
return False
def _login_headers(self,fileFormat: str,length: int) -> None:
self.send_response(200)
self.send_header('Content-type', fileFormat)
self.send_header('Content-Length', str(length))
self.send_header('Host', self.server.domainFull)
self.send_header('WWW-Authenticate', \
'title="Login to Epicyon", Basic realm="epicyon"')
self.send_header('X-Robots-Tag','noindex')
self.end_headers()
def _logout_headers(self,fileFormat: str,length: int) -> None:
self.send_response(200)
self.send_header('Content-type', fileFormat)
self.send_header('Content-Length', str(length))
self.send_header('Set-Cookie', 'epicyon=; SameSite=Strict')
self.send_header('Host', self.server.domainFull)
self.send_header('WWW-Authenticate', \
'title="Login to Epicyon", Basic realm="epicyon"')
self.send_header('X-Robots-Tag','noindex')
self.end_headers()
def _set_headers_base(self,fileFormat: str,length: int,cookie: str) -> None:
self.send_response(200)
self.send_header('Content-type', fileFormat)
if length>-1:
self.send_header('Content-Length', str(length))
if cookie:
self.send_header('Cookie', cookie)
self.send_header('Host', self.server.domainFull)
self.send_header('InstanceID', self.server.instanceId)
self.send_header('X-Robots-Tag','noindex')
self.send_header('Cache-Control','public, max-age=0')
self.send_header('X-Clacks-Overhead','GNU Natalie Nguyen')
self.send_header('Accept-Ranges','none')
def _set_headers(self,fileFormat: str,length: int,cookie: str) -> None:
self._set_headers_base(fileFormat,length,cookie)
self.end_headers()
def _set_headers_head(self,fileFormat: str,length: int,etag: str) -> None:
self._set_headers_base(fileFormat,length,None)
if etag:
self.send_header('ETag',etag)
self.end_headers()
def _set_headers_etag(self,mediaFilename: str,fileFormat: str, \
data,cookie: str) -> None:
self._set_headers_base(fileFormat,len(data),cookie)
etag=None
if os.path.isfile(mediaFilename+'.etag'):
try:
with open(mediaFilename+'.etag', 'r') as etagFile:
etag = etagFile.read()
except:
pass
if not etag:
etag=sha1(data).hexdigest()
try:
with open(mediaFilename+'.etag', 'w') as etagFile:
etagFile.write(etag)
except:
pass
if etag:
self.send_header('ETag',etag)
self.end_headers()
def _redirect_headers(self,redirect: str,cookie: str) -> None:
self.send_response(303)
#self.send_header('Content-type', 'text/html')
if cookie:
self.send_header('Cookie', cookie)
if '://' not in redirect:
print('REDIRECT ERROR: redirect is not an absolute url '+redirect)
self.send_header('Location', redirect)
self.send_header('Host', self.server.domainFull)
self.send_header('InstanceID', self.server.instanceId)
self.send_header('Content-Length', '0')
self.send_header('X-Robots-Tag','noindex')
self.end_headers()
def _httpReturnCode(self,httpCode: int,httpDescription: str) -> None:
msg="<html><head></head><body><h1>"+str(httpCode)+" "+httpDescription+"</h1></body></html>"
msg=msg.encode('utf-8')
self.send_response(httpCode)
self.send_header('Content-Type', 'text/html; charset=utf-8')
self.send_header('Content-Length', str(len(msg)))
self.send_header('X-Robots-Tag','noindex')
self.end_headers()
try:
self.wfile.write(msg)
except Exception as e:
print('Error when showing '+str(httpCode))
print(e)
def _200(self) -> None:
self._httpReturnCode(200,'Ok')
def _404(self) -> None:
self._httpReturnCode(404,'Not Found')
def _304(self) -> None:
self._httpReturnCode(304,'Resource has not changed')
def _400(self) -> None:
self._httpReturnCode(400,'Bad Request')
def _503(self) -> None:
self._httpReturnCode(503,'Service Unavailable')
def _write(self,msg) -> None:
tries=0
while tries<5:
try:
self.wfile.write(msg)
break
except Exception as e:
print(e)
time.sleep(1)
tries+=1
def _robotsTxt(self) -> bool:
if not self.path.lower().startswith('/robot'):
return False
msg='User-agent: *\nDisallow: /'
msg=msg.encode('utf-8')
self._set_headers('text/plain; charset=utf-8',len(msg),None)
self._write(msg)
return True
def _mastoApi(self) -> bool:
"""This is a vestigil mastodon API for the purpose
of returning an empty result to sites like
https://mastopeek.app-dist.eu
"""
if not self.path.startswith('/api/v1/'):
return False
if self.server.debug:
print('DEBUG: mastodon api '+self.path)
if self.path=='/api/v1/instance':
adminNickname=getConfigParam(self.server.baseDir,'admin')
instanceDescriptionShort=getConfigParam(self.server.baseDir,'instanceDescriptionShort')
instanceDescription=getConfigParam(self.server.baseDir,'instanceDescription')
instanceTitle=getConfigParam(self.server.baseDir,'instanceTitle')
instanceJson= \
metaDataInstance(instanceTitle, \
instanceDescriptionShort, \
instanceDescription, \
self.server.httpPrefix, \
self.server.baseDir, \
adminNickname, \
self.server.domain,self.server.domainFull, \
self.server.registration, \
self.server.systemLanguage, \
self.server.projectVersion)
msg=json.dumps(instanceJson).encode('utf-8')
if self.headers.get('Accept'):
if 'application/ld+json' in self.headers['Accept']:
self._set_headers('application/ld+json',len(msg),None)
else:
self._set_headers('application/json',len(msg),None)
else:
self._set_headers('application/ld+json',len(msg),None)
self._write(msg)
print('instance metadata sent')
return True
if self.path.startswith('/api/v1/instance/peers'):
# This is just a dummy result.
# Showing the full list of peers would have privacy implications.
# On a large instance you are somewhat lost in the crowd, but on small
# instances a full list of peers would convey a lot of information about
# the interests of a small number of accounts
msg=json.dumps(['mastodon.social',self.server.domainFull]).encode('utf-8')
if self.headers.get('Accept'):
if 'application/ld+json' in self.headers['Accept']:
self._set_headers('application/ld+json',len(msg),None)
else:
self._set_headers('application/json',len(msg),None)
else:
self._set_headers('application/ld+json',len(msg),None)
self._write(msg)
print('instance peers metadata sent')
return True
if self.path.startswith('/api/v1/instance/activity'):
# This is just a dummy result.
msg=json.dumps([]).encode('utf-8')
if self.headers.get('Accept'):
if 'application/ld+json' in self.headers['Accept']:
self._set_headers('application/ld+json',len(msg),None)
else:
self._set_headers('application/json',len(msg),None)
else:
self._set_headers('application/ld+json',len(msg),None)
self._write(msg)
print('instance activity metadata sent')
return True
self._404()
return True
def _nodeinfo(self) -> bool:
if not self.path.startswith('/nodeinfo/2.0'):
return False
if self.server.debug:
print('DEBUG: nodeinfo '+self.path)
info=metaDataNodeInfo(self.server.baseDir,self.server.registration,self.server.projectVersion)
if info:
msg=json.dumps(info).encode('utf-8')
if self.headers.get('Accept'):
if 'application/ld+json' in self.headers['Accept']:
self._set_headers('application/ld+json',len(msg),None)
else:
self._set_headers('application/json',len(msg),None)
else:
self._set_headers('application/ld+json',len(msg),None)
self._write(msg)
print('nodeinfo sent')
return True
self._404()
return True
def _webfinger(self) -> bool:
if not self.path.startswith('/.well-known'):
return False
if self.server.debug:
print('DEBUG: WEBFINGER well-known')
if self.server.debug:
print('DEBUG: WEBFINGER host-meta')
if self.path.startswith('/.well-known/host-meta'):
wfResult=webfingerMeta(self.server.httpPrefix,self.server.domainFull)
if wfResult:
msg=wfResult.encode('utf-8')
self._set_headers('application/xrd+xml',len(msg),None)
self._write(msg)
return True
self._404()
return True
if self.path.startswith('/.well-known/nodeinfo'):
wfResult=webfingerNodeInfo(self.server.httpPrefix,self.server.domainFull)
if wfResult:
msg=json.dumps(wfResult).encode('utf-8')
if self.headers.get('Accept'):
if 'application/ld+json' in self.headers['Accept']:
self._set_headers('application/ld+json',len(msg),None)
else:
self._set_headers('application/json',len(msg),None)
else:
self._set_headers('application/ld+json',len(msg),None)
self._write(msg)
return True
self._404()
return True
if self.server.debug:
print('DEBUG: WEBFINGER lookup '+self.path+' '+str(self.server.baseDir))
wfResult=webfingerLookup(self.path,self.server.baseDir,self.server.port,self.server.debug)
if wfResult:
msg=json.dumps(wfResult).encode('utf-8')
self._set_headers('application/jrd+json',len(msg),None)
self._write(msg)
else:
if self.server.debug:
print('DEBUG: WEBFINGER lookup 404 '+self.path)
self._404()
return True
def _permittedDir(self,path: str) -> bool:
"""These are special paths which should not be accessible
directly via GET or POST
"""
if path.startswith('/wfendpoints') or \
path.startswith('/keys') or \
path.startswith('/accounts'):
return False
return True
def _postToOutbox(self,messageJson: {},version: str,postToNickname=None) -> bool:
"""post is received by the outbox
Client to server message post
https://www.w3.org/TR/activitypub/#client-to-server-outbox-delivery
"""
if postToNickname:
print('Posting to nickname '+postToNickname)
self.postToNickname=postToNickname
return postMessageToOutbox(messageJson,self.postToNickname, \
self.server,self.server.baseDir,self.server.httpPrefix, \
self.server.domain,self.server.domainFull,self.server.port, \
self.server.recentPostsCache,self.server.followersThreads, \
self.server.federationList,self.server.sendThreads, \
self.server.postLog,self.server.cachedWebfingers, \
self.server.personCache,self.server.allowDeletion, \
self.server.useTor,version,self.server.debug)
def _postToOutboxThread(self,messageJson: {}) -> bool:
"""Creates a thread to send a post
"""
accountOutboxThreadName=self.postToNickname
if not accountOutboxThreadName:
accountOutboxThreadName='*'
if self.server.outboxThread.get(accountOutboxThreadName):
print('Waiting for previous outbox thread to end')
waitCtr=0
while self.server.outboxThread[accountOutboxThreadName].isAlive() and waitCtr<8:
time.sleep(1)
waitCtr+=1
if waitCtr>=8:
self.server.outboxThread[accountOutboxThreadName].kill()
print('Creating outbox thread')
self.server.outboxThread[accountOutboxThreadName]= \
threadWithTrace(target=self._postToOutbox, \
args=(messageJson.copy(),__version__),daemon=True)
print('Starting outbox thread')
self.server.outboxThread[accountOutboxThreadName].start()
return True
def _inboxQueueCleardown(self) -> None:
""" Check if the queue is full and remove oldest items if it is
"""
if len(self.server.inboxQueue)>=self.server.maxQueueLength:
print('Inbox queue is full ('+str(self.server.maxQueueLength)+' items). Removing oldest items.')
cleardownStartTime=time.time()
removals=0
while len(self.server.inboxQueue) >= self.server.maxQueueLength-4:
queueFilename=self.server.inboxQueue[0]
if os.path.isfile(queueFilename):
try:
os.remove(queueFilename)
removals+=1
except:
print('WARN: unable to remove inbox queue file '+queueFilename)
pass
self.server.inboxQueue.pop(0)
timeDiff=str(int((time.time()-cleardownStartTime)*1000))
print('Inbox cleardown took '+timeDiff+' mS. Removed '+str(removals)+' items.')
def _updateInboxQueue(self,nickname: str,messageJson: {}, \
messageBytes: str) -> int:
"""Update the inbox queue
"""
self._inboxQueueCleardown()
# Convert the headers needed for signature verification to dict
headersDict={}
headersDict['host']=self.headers['host']
headersDict['signature']=self.headers['signature']
if self.headers.get('Date'):
headersDict['Date']=self.headers['Date']
if self.headers.get('digest'):
headersDict['digest']=self.headers['digest']
if self.headers.get('Content-type'):
headersDict['Content-type']=self.headers['Content-type']
if self.headers.get('Content-Length'):
headersDict['Content-Length']=self.headers['Content-Length']
elif self.headers.get('content-length'):
headersDict['content-length']=self.headers['content-length']
# For follow activities add a 'to' field, which is a copy
# of the object field
messageJson,toFieldExists= \
addToField('Follow',messageJson,self.server.debug)
# For like activities add a 'to' field, which is a copy of
# the actor within the object field
messageJson,toFieldExists= \
addToField('Like',messageJson,self.server.debug)
beginSaveTime=time.time()
# save the json for later queue processing
queueFilename = \
savePostToInboxQueue(self.server.baseDir,
self.server.httpPrefix,
nickname,
self.server.domainFull,
messageJson,
messageBytes.decode('utf-8'),
headersDict,
self.path,
self.server.debug)
if queueFilename:
# add json to the queue
if queueFilename not in self.server.inboxQueue:
self.server.inboxQueue.append(queueFilename)
if self.server.debug:
timeDiff=int((time.time()-beginSaveTime)*1000)
if timeDiff>200:
print('SLOW: slow save of inbox queue item '+queueFilename+' took '+str(timeDiff)+' mS')
self.send_response(201)
self.end_headers()
self.server.POSTbusy=False
return 0
return 2
def _isAuthorized(self) -> bool:
if self.path.startswith('/icons/') or \
self.path.startswith('/avatars/') or \
self.path.startswith('/favicon.ico'):
return False
# token based authenticated used by the web interface
if self.headers.get('Cookie'):
if self.headers['Cookie'].startswith('epicyon='):
tokenStr=self.headers['Cookie'].split('=',1)[1].strip()
if ';' in tokenStr:
tokenStr=tokenStr.split(';')[0].strip()
if self.server.tokensLookup.get(tokenStr):
nickname=self.server.tokensLookup[tokenStr]
# default to the inbox of the person
if self.path=='/':
self.path='/users/'+nickname+'/inbox'
# check that the path contains the same nickname as the cookie
# otherwise it would be possible to be authorized to use
# an account you don't own
if '/'+nickname+'/' in self.path:
return True
if self.path.endswith('/'+nickname):
return True
print('AUTH: nickname '+nickname+' was not found in path '+self.path)
return False
if self.server.debug:
print('AUTH: epicyon cookie authorization failed, header='+self.headers['Cookie'].replace('epicyon=','')+' tokenStr='+tokenStr+' tokens='+str(self.server.tokensLookup))
return False
print('AUTH: Header cookie was not authorized')
return False
# basic auth
if self.headers.get('Authorization'):
if authorize(self.server.baseDir,self.path, \
self.headers['Authorization'], \
self.server.debug):
return True
print('AUTH: Basic auth did not authorize '+self.headers['Authorization'])
return False
def _clearLoginDetails(self,nickname: str):
"""Clears login details for the given account
"""
# remove any token
if self.server.tokens.get(nickname):
del self.server.tokensLookup[self.server.tokens[nickname]]
del self.server.tokens[nickname]
self.send_response(303)
self.send_header('Content-Length', '0')
self.send_header('Set-Cookie', 'epicyon=; SameSite=Strict')
self.send_header('Location', \
self.server.httpPrefix+'://'+ \
self.server.domainFull+'/login')
self.send_header('X-Robots-Tag','noindex')
self.end_headers()
def _benchmarkGETtimings(self,GETstartTime,GETtimings: [],getID: int):
"""Updates a list containing how long each segment of GET takes
"""
if self.server.debug:
timeDiff=int((time.time()-GETstartTime)*1000)
logEvent=False
if timeDiff>100:
logEvent=True
if GETtimings:
timeDiff=int(timeDiff-int(GETtimings[-1]))
GETtimings.append(str(timeDiff))
if logEvent:
ctr=1
for timeDiff in GETtimings:
print('GET TIMING|'+str(ctr)+'|'+timeDiff)
ctr+=1
def _benchmarkPOSTtimings(self,POSTstartTime,POSTtimings: [],postID: int):
"""Updates a list containing how long each segment of POST takes
"""
if self.server.debug:
timeDiff=int((time.time()-POSTstartTime)*1000)
logEvent=False
if timeDiff>100:
logEvent=True
if POSTtimings:
timeDiff=int(timeDiff-int(POSTtimings[-1]))
POSTtimings.append(str(timeDiff))
if logEvent:
ctr=1
for timeDiff in POSTtimings:
print('POST TIMING|'+str(ctr)+'|'+timeDiff)
ctr+=1
def do_GET(self):
GETstartTime=time.time()
GETtimings=[]
# Since fediverse crawlers are quite active, make returning info to them high priority
# get nodeinfo endpoint
if self._nodeinfo():
return
self._benchmarkGETtimings(GETstartTime,GETtimings,1)
# minimal mastodon api
if self._mastoApi():
return
self._benchmarkGETtimings(GETstartTime,GETtimings,2)
if self.path=='/logout':
msg=htmlLogin(self.server.translate, \
self.server.baseDir,False).encode('utf-8')
self._logout_headers('text/html',len(msg))
self._write(msg)
return
self._benchmarkGETtimings(GETstartTime,GETtimings,3)
# replace https://domain/@nick with https://domain/users/nick
if self.path.startswith('/@'):
self.path=self.path.replace('/@','/users/')
# redirect music to #nowplaying list
if self.path=='/music' or self.path=='/nowplaying':
self.path='/tags/nowplaying'
if self.server.debug:
print('DEBUG: GET from '+self.server.baseDir+ \
' path: '+self.path+' busy: '+ \
str(self.server.GETbusy))
if self.server.debug:
print(str(self.headers))
cookie=None
if self.headers.get('Cookie'):
cookie=self.headers['Cookie']
self._benchmarkGETtimings(GETstartTime,GETtimings,4)
# check authorization
authorized = self._isAuthorized()
if self.server.debug:
if authorized:
print('GET Authorization granted')
else:
print('GET Not authorized')
self._benchmarkGETtimings(GETstartTime,GETtimings,5)
if not self.server.session:
print('Starting new session')
self.server.session= \
createSession(self.server.useTor)
self._benchmarkGETtimings(GETstartTime,GETtimings,6)
# is this a html request?
htmlGET=False
if self.headers.get('Accept'):
if self._requestHTTP():
htmlGET=True
else:
if self.headers.get('Connection'):
# https://developer.mozilla.org/en-US/docs/Web/HTTP/Protocol_upgrade_mechanism
if self.headers.get('Upgrade'):
print('HTTP Connection request: '+self.headers['Upgrade'])
else:
print('HTTP Connection request: '+self.headers['Connection'])
self._200()
else:
print('WARN: No Accept header '+str(self.headers))
self._400()
return
self._benchmarkGETtimings(GETstartTime,GETtimings,7)
# treat shared inbox paths consistently
if self.path=='/sharedInbox' or \
self.path=='/users/inbox' or \
self.path=='/actor/inbox' or \
self.path=='/users/'+self.server.domain:
# if shared inbox is not enabled
if not self.server.enableSharedInbox:
self._503()
return
self.path='/inbox'
self._benchmarkGETtimings(GETstartTime,GETtimings,8)
# show the person options screen with view/follow/block/report
if htmlGET and '/users/' in self.path:
if '?options=' in self.path:
optionsStr=self.path.split('?options=')[1]
originPathStr=self.path.split('?options=')[0]
if ';' in optionsStr:
pageNumber=1
optionsList=optionsStr.split(';')
optionsActor=optionsList[0]
optionsPageNumber=optionsList[1]
optionsProfileUrl=optionsList[2]
if optionsPageNumber.isdigit():
pageNumber=int(optionsPageNumber)
optionsLink=None
if len(optionsList)>3:
optionsLink=optionsList[3]
donateUrl=None
PGPpubKey=None
xmppAddress=None
matrixAddress=None
emailAddress=None
actorJson=getPersonFromCache(self.server.baseDir,optionsActor,self.server.personCache)
if actorJson:
donateUrl=getDonationUrl(actorJson)
xmppAddress=getXmppAddress(actorJson)
matrixAddress=getMatrixAddress(actorJson)
emailAddress=getEmailAddress(actorJson)
PGPpubKey=getPGPpubKey(actorJson)
msg=htmlPersonOptions(self.server.translate, \
self.server.baseDir, \
self.server.domain, \
originPathStr, \
optionsActor, \
optionsProfileUrl, \
optionsLink, \
pageNumber,donateUrl, \
xmppAddress,matrixAddress, \
PGPpubKey,emailAddress).encode()
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
return
originPathStrAbsolute=self.server.httpPrefix+'://'+self.server.domainFull+originPathStr
self._redirect_headers(originPathStrAbsolute,cookie)
return
self._benchmarkGETtimings(GETstartTime,GETtimings,9)
# remove a shared item
if htmlGET and '?rmshare=' in self.path:
shareName=self.path.split('?rmshare=')[1]
shareName=shareName.replace('%20',' ').replace('%40','@').replace('%3A',':').replace('%2F','/').replace('%23','#').strip()
actor= \
self.server.httpPrefix+'://'+self.server.domainFull+ \
self.path.split('?rmshare=')[0]
msg=htmlRemoveSharedItem(self.server.translate, \
self.server.baseDir, \
actor,shareName).encode()
if not msg:
self._redirect_headers(actor+'/tlshares',cookie)
return
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
return
self._benchmarkGETtimings(GETstartTime,GETtimings,10)
if self.path.startswith('/terms'):
msg=htmlTermsOfService(self.server.baseDir, \
self.server.httpPrefix, \
self.server.domainFull).encode()
self._login_headers('text/html',len(msg))
self._write(msg)
return
self._benchmarkGETtimings(GETstartTime,GETtimings,11)
if self.path.startswith('/about'):
msg=htmlAbout(self.server.baseDir, \
self.server.httpPrefix, \
self.server.domainFull).encode()
self._login_headers('text/html',len(msg))
self._write(msg)
return
self._benchmarkGETtimings(GETstartTime,GETtimings,12)
# send robots.txt if asked
if self._robotsTxt():
return
self._benchmarkGETtimings(GETstartTime,GETtimings,13)
# if not authorized then show the login screen
if htmlGET and self.path!='/login' and self.path!='/':
if '/media/' not in self.path and \
'/sharefiles/' not in self.path and \
'/statuses/' not in self.path and \
'/emoji/' not in self.path and \
'/tags/' not in self.path and \
'/avatars/' not in self.path and \
'/icons/' not in self.path:
divertToLoginScreen=True
if self.path.startswith('/users/'):
nickStr=self.path.split('/users/')[1]
if '/' not in nickStr and '?' not in nickStr:
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:
if self.server.debug:
print('DEBUG: divertToLoginScreen='+str(divertToLoginScreen))
print('DEBUG: authorized='+str(authorized))
print('DEBUG: path='+self.path)
self.send_response(303)
self.send_header('Location', \
self.server.httpPrefix+'://'+ \
self.server.domainFull+'/login')
self.send_header('Content-Length', '0')
self.send_header('X-Robots-Tag','noindex')
self.end_headers()
return
self._benchmarkGETtimings(GETstartTime,GETtimings,14)
# get css
# Note that this comes before the busy flag to avoid conflicts
if self.path.endswith('.css'):
if os.path.isfile('epicyon-profile.css'):
tries=0
while tries<5:
try:
with open('epicyon-profile.css', 'r') as cssfile:
css = cssfile.read()
break
except Exception as e:
print(e)
time.sleep(1)
tries+=1
msg=css.encode('utf-8')
self._set_headers('text/css',len(msg),cookie)
self._write(msg)
return
self._404()
return
self._benchmarkGETtimings(GETstartTime,GETtimings,15)
# image on login screen
if self.path=='/login.png' or \
self.path=='/login.gif' or \
self.path=='/login.webp' or \
self.path=='/login.jpeg' or \
self.path=='/login.jpg':
mediaFilename= \
self.server.baseDir+'/accounts'+self.path
if os.path.isfile(mediaFilename):
tries=0
mediaBinary=None
while tries<5:
try:
with open(mediaFilename, 'rb') as avFile:
mediaBinary = avFile.read()
break
except Exception as e:
print(e)
time.sleep(1)
tries+=1
if mediaBinary:
self._set_headers('image/png',len(mediaBinary),cookie)
self._write(mediaBinary)
return
self._404()
return
self._benchmarkGETtimings(GETstartTime,GETtimings,16)
# login screen background image
if self.path=='/login-background.png':
mediaFilename= \
self.server.baseDir+'/accounts/login-background.png'
if os.path.isfile(mediaFilename):
tries=0
mediaBinary=None
while tries<5:
try:
with open(mediaFilename, 'rb') as avFile:
mediaBinary = avFile.read()
break
except Exception as e:
print(e)
time.sleep(1)
tries+=1
if mediaBinary:
self._set_headers('image/png',len(mediaBinary),cookie)
self._write(mediaBinary)
return
self._404()
return
self._benchmarkGETtimings(GETstartTime,GETtimings,17)
# follow screen background image
if self.path=='/follow-background.png':
mediaFilename= \
self.server.baseDir+'/accounts/follow-background.png'
if os.path.isfile(mediaFilename):
tries=0
mediaBinary=None
while tries<5:
try:
with open(mediaFilename, 'rb') as avFile:
mediaBinary = avFile.read()
break
except Exception as e:
print(e)
time.sleep(1)
tries+=1
if mediaBinary:
self._set_headers('image/png',len(mediaBinary),cookie)
self._write(mediaBinary)
return
self._404()
return
self._benchmarkGETtimings(GETstartTime,GETtimings,18)
# emoji images
if '/emoji/' in self.path:
if self.path.endswith('.png') or \
self.path.endswith('.jpg') or \
self.path.endswith('.gif'):
emojiStr=self.path.split('/emoji/')[1]
emojiFilename= \
self.server.baseDir+'/emoji/'+emojiStr
if os.path.isfile(emojiFilename):
mediaImageType='png'
if emojiFilename.endswith('.png'):
mediaImageType='png'
elif emojiFilename.endswith('.jpg'):
mediaImageType='jpeg'
elif emojiFilename.endswith('.webp'):
mediaImageType='webp'
else:
mediaImageType='gif'
with open(emojiFilename, 'rb') as avFile:
mediaBinary = avFile.read()
self._set_headers('image/'+mediaImageType,len(mediaBinary),cookie)
self._write(mediaBinary)
return
self._404()
return
self._benchmarkGETtimings(GETstartTime,GETtimings,19)
# show media
# Note that this comes before the busy flag to avoid conflicts
if '/media/' in self.path:
if self.path.endswith('.png') or \
self.path.endswith('.jpg') or \
self.path.endswith('.gif') or \
self.path.endswith('.webp') or \
self.path.endswith('.mp4') or \
self.path.endswith('.ogv') or \
self.path.endswith('.mp3') or \
self.path.endswith('.ogg'):
mediaStr=self.path.split('/media/')[1]
mediaFilename= \
self.server.baseDir+'/media/'+mediaStr
if os.path.isfile(mediaFilename):
mediaFileType='image/png'
if mediaFilename.endswith('.png'):
mediaFileType='image/png'
elif mediaFilename.endswith('.jpg'):
mediaFileType='image/jpeg'
elif mediaFilename.endswith('.gif'):
mediaFileType='image/gif'
elif mediaFilename.endswith('.webp'):
mediaFileType='image/webp'
elif mediaFilename.endswith('.mp4'):
mediaFileType='video/mp4'
elif mediaFilename.endswith('.ogv'):
mediaFileType='video/ogv'
elif mediaFilename.endswith('.mp3'):
mediaFileType='audio/mpeg'
elif mediaFilename.endswith('.ogg'):
mediaFileType='audio/ogg'
# does an etag header exist?
etagHeader='If-None-Match'
if not self.headers.get(etagHeader):
etagHeader='if-none-match'
if not self.headers.get(etagHeader):
etagHeader='If-none-match'
if self.headers.get(etagHeader):
oldEtag=self.headers['If-None-Match']
if os.path.isfile(mediaFilename+'.etag'):
# load the etag from file
currEtag=''
try:
with open(mediaFilename, 'r') as etagFile:
currEtag = etagFile.read()
except:
pass
if oldEtag==currEtag:
# The file has not changed
self._304()
return
with open(mediaFilename, 'rb') as avFile:
mediaBinary = avFile.read()
self._set_headers_etag(mediaFilename,mediaFileType,mediaBinary,cookie)
self._write(mediaBinary)
return
self._404()
return
self._benchmarkGETtimings(GETstartTime,GETtimings,20)
# 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('.webp') or \
self.path.endswith('.gif'):
mediaStr=self.path.split('/sharefiles/')[1]
mediaFilename= \
self.server.baseDir+'/sharefiles/'+mediaStr
if os.path.isfile(mediaFilename):
mediaFileType='png'
if mediaFilename.endswith('.png'):
mediaFileType='png'
elif mediaFilename.endswith('.jpg'):
mediaFileType='jpeg'
elif mediaFilename.endswith('.webp'):
mediaFileType='webp'
else:
mediaFileType='gif'
with open(mediaFilename, 'rb') as avFile:
mediaBinary = avFile.read()
self._set_headers('image/'+mediaFileType,len(mediaBinary),cookie)
self._write(mediaBinary)
return
self._404()
return
self._benchmarkGETtimings(GETstartTime,GETtimings,21)
# icon images
# Note that this comes before the busy flag to avoid conflicts
if self.path.startswith('/icons/'):
if self.path.endswith('.png'):
mediaStr=self.path.split('/icons/')[1]
mediaFilename= \
self.server.baseDir+'/img/icons/'+mediaStr
if self.server.iconsCache.get(mediaStr):
mediaBinary=self.server.iconsCache[mediaStr]
self._set_headers('image/png',len(mediaBinary),cookie)
self._write(mediaBinary)
return
else:
if os.path.isfile(mediaFilename):
with open(mediaFilename, 'rb') as avFile:
mediaBinary = avFile.read()
self._set_headers('image/png',len(mediaBinary),cookie)
self._write(mediaBinary)
self.server.iconsCache[mediaStr]=mediaBinary
return
self._404()
return
self._benchmarkGETtimings(GETstartTime,GETtimings,22)
# cached avatar images
# Note that this comes before the busy flag to avoid conflicts
if self.path.startswith('/avatars/'):
mediaFilename= \
self.server.baseDir+'/cache/'+self.path
if os.path.isfile(mediaFilename):
with open(mediaFilename, 'rb') as avFile:
mediaBinary = avFile.read()
if mediaFilename.endswith('.png'):
self._set_headers('image/png',len(mediaBinary),cookie)
elif mediaFilename.endswith('.jpg'):
self._set_headers('image/jpeg',len(mediaBinary),cookie)
elif mediaFilename.endswith('.gif'):
self._set_headers('image/gif',len(mediaBinary),cookie)
else:
# default to jpeg
self._set_headers('image/jpeg',len(mediaBinary),cookie)
#self._404()
return
self._write(mediaBinary)
return
self._404()
return
self._benchmarkGETtimings(GETstartTime,GETtimings,23)
# show avatar or background image
# Note that this comes before the busy flag to avoid conflicts
if '/users/' in self.path:
if self.path.endswith('.png') or \
self.path.endswith('.jpg') or \
self.path.endswith('.webp') or \
self.path.endswith('.gif'):
avatarStr=self.path.split('/users/')[1]
if '/' in avatarStr and '.temp.' not in self.path:
avatarNickname=avatarStr.split('/')[0]
avatarFile=avatarStr.split('/')[1]
# remove any numbers, eg. avatar123.png becomes avatar.png
if avatarFile.startswith('avatar'):
avatarFile='avatar.'+avatarFile.split('.')[1]
elif avatarFile.startswith('image'):
avatarFile='image.'+avatarFile.split('.')[1]
avatarFilename= \
self.server.baseDir+'/accounts/'+ \
avatarNickname+'@'+ \
self.server.domain+'/'+avatarFile
if os.path.isfile(avatarFilename):
mediaImageType='png'
if avatarFile.endswith('.png'):
mediaImageType='png'
elif avatarFile.endswith('.jpg'):
mediaImageType='jpeg'
elif avatarFile.endswith('.gif'):
mediaImageType='gif'
else:
mediaImageType='webp'
with open(avatarFilename, 'rb') as avFile:
mediaBinary = avFile.read()
self._set_headers('image/'+mediaImageType, \
len(mediaBinary),cookie)
self._write(mediaBinary)
return
self._benchmarkGETtimings(GETstartTime,GETtimings,24)
# This busy state helps to avoid flooding
# Resources which are expected to be called from a web page
# should be above this
if self.server.GETbusy:
currTimeGET=int(time.time())
if currTimeGET-self.server.lastGET==0:
if self.server.debug:
print('DEBUG: GET Busy')
self.send_response(429)
self.end_headers()
return
self.server.lastGET=currTimeGET
self.server.GETbusy=True
self._benchmarkGETtimings(GETstartTime,GETtimings,25)
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
if self._webfinger():
self.server.GETbusy=False
return
self._benchmarkGETtimings(GETstartTime,GETtimings,26)
if self.path.startswith('/login') or \
(self.path=='/' and not authorized):
# request basic auth
msg=htmlLogin(self.server.translate, \
self.server.baseDir).encode('utf-8')
self._login_headers('text/html',len(msg))
self._write(msg)
self.server.GETbusy=False
return
self._benchmarkGETtimings(GETstartTime,GETtimings,27)
# hashtag search
if self.path.startswith('/tags/') or \
(authorized and '/tags/' in self.path):
pageNumber=1
if '?page=' in self.path:
pageNumberStr=self.path.split('?page=')[1]
if pageNumberStr.isdigit():
pageNumber=int(pageNumberStr)
hashtag=self.path.split('/tags/')[1]
if '?page=' in hashtag:
hashtag=hashtag.split('?page=')[0]
if isBlockedHashtag(self.server.baseDir,hashtag):
msg=htmlHashtagBlocked(self.server.baseDir).encode('utf-8')
self._login_headers('text/html',len(msg))
self._write(msg)
self.server.GETbusy=False
return
nickname=None
if '/users/' in self.path:
actor=self.server.httpPrefix+'://'+self.server.domainFull+self.path
nickname= \
getNicknameFromActor(actor)
hashtagStr= \
htmlHashtagSearch(nickname, \
self.server.domain,self.server.port, \
self.server.recentPostsCache, \
self.server.maxRecentPosts, \
self.server.translate, \
self.server.baseDir,hashtag,pageNumber, \
maxPostsInFeed,self.server.session, \
self.server.cachedWebfingers, \
self.server.personCache, \
self.server.httpPrefix, \
self.server.projectVersion)
if hashtagStr:
msg=hashtagStr.encode()
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
else:
originPathStr=self.path.split('/tags/')[0]
originPathStrAbsolute=self.server.httpPrefix+'://'+self.server.domainFull+originPathStr
self._redirect_headers(originPathStrAbsolute+'/search',cookie)
self.server.GETbusy=False
return
self._benchmarkGETtimings(GETstartTime,GETtimings,28)
# search for a fediverse address, shared item or emoji
# from the web interface by selecting search icon
if htmlGET and '/users/' in self.path:
if self.path.endswith('/search') or \
'/search?' in self.path:
if '?' in self.path:
self.path=self.path.split('?')[0]
# show the search screen
msg=htmlSearch(self.server.translate, \
self.server.baseDir,self.path).encode()
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
self.server.GETbusy=False
return
self._benchmarkGETtimings(GETstartTime,GETtimings,29)
# Show the calendar for a user
if htmlGET and '/users/' in self.path:
if '/calendar' in self.path:
# show the calendar screen
msg=htmlCalendar(self.server.translate, \
self.server.baseDir,self.path, \
self.server.httpPrefix, \
self.server.domainFull).encode()
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
self.server.GETbusy=False
return
# Show confirmation for deleting a calendar event
if htmlGET and '/users/' in self.path:
if '/eventdelete' in self.path and \
'?time=' in self.path and \
'?id=' in self.path:
postId=self.path.split('?id=')[1]
if '?' in postId:
postId=postId.split('?')[0]
postTime=self.path.split('?time=')[1]
if '?' in postTime:
postTime=postTime.split('?')[0]
postYear=self.path.split('?year=')[1]
if '?' in postYear:
postYear=postYear.split('?')[0]
postMonth=self.path.split('?month=')[1]
if '?' in postMonth:
postMonth=postMonth.split('?')[0]
postDay=self.path.split('?day=')[1]
if '?' in postDay:
postDay=postDay.split('?')[0]
# show the confirmation screen screen
msg=htmlCalendarDeleteConfirm(self.server.translate, \
self.server.baseDir,self.path, \
self.server.httpPrefix, \
self.server.domainFull,
postId,postTime, \
postYear,postMonth,postDay)
if not msg:
actor= \
self.server.httpPrefix+'://'+self.server.domainFull+ \
self.path.split('/eventdelete')[0]
self._redirect_headers(actor+'/calendar',cookie)
return
msg=msg.encode()
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
self.server.GETbusy=False
return
self._benchmarkGETtimings(GETstartTime,GETtimings,30)
# search for emoji by name
if htmlGET and '/users/' in self.path:
if self.path.endswith('/searchemoji'):
# show the search screen
msg=htmlSearchEmojiTextEntry(self.server.translate, \
self.server.baseDir, \
self.path).encode()
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
self.server.GETbusy=False
return
self._benchmarkGETtimings(GETstartTime,GETtimings,31)
repeatPrivate=False
if htmlGET and '?repeatprivate=' in self.path:
repeatPrivate=True
self.path=self.path.replace('?repeatprivate=','?repeat=')
# announce/repeat from the web interface
if htmlGET and '?repeat=' in self.path:
pageNumber=1
repeatUrl=self.path.split('?repeat=')[1]
if '?' in repeatUrl:
repeatUrl=repeatUrl.split('?')[0]
timelineBookmark=''
if '?bm=' in self.path:
timelineBookmark=self.path.split('?bm=')[1]
if '?' in timelineBookmark:
timelineBookmark=timelineBookmark.split('?')[0]
timelineBookmark='#'+timelineBookmark
if '?page=' in self.path:
pageNumberStr=self.path.split('?page=')[1]
if '?' in pageNumberStr:
pageNumberStr=pageNumberStr.split('?')[0]
if pageNumberStr.isdigit():
pageNumber=int(pageNumberStr)
timelineStr='inbox'
if '?tl=' in self.path:
timelineStr=self.path.split('?tl=')[1]
if '?' in timelineStr:
timelineStr=timelineStr.split('?')[0]
actor=self.path.split('?repeat=')[0]
self.postToNickname=getNicknameFromActor(actor)
if not self.postToNickname:
print('WARN: unable to find nickname in '+actor)
self.server.GETbusy=False
actorAbsolute=self.server.httpPrefix+'://'+self.server.domainFull+actor
self._redirect_headers(actorAbsolute+'/'+timelineStr+ \
'?page='+str(pageNumber),cookie)
return
if not self.server.session:
self.server.session= \
createSession(self.server.useTor)
self.server.actorRepeat=self.path.split('?actor=')[1]
announceToStr=self.server.httpPrefix+'://'+self.server.domain+'/users/'+self.postToNickname+'/followers'
if not repeatPrivate:
announceToStr='https://www.w3.org/ns/activitystreams#Public'
announceJson= \
createAnnounce(self.server.session, \
self.server.baseDir, \
self.server.federationList, \
self.postToNickname, \
self.server.domain,self.server.port, \
announceToStr, \
None,self.server.httpPrefix, \
repeatUrl,False,False, \
self.server.sendThreads, \
self.server.postLog, \
self.server.personCache, \
self.server.cachedWebfingers, \
self.server.debug, \
self.server.projectVersion)
if announceJson:
self._postToOutboxThread(announceJson)
self.server.GETbusy=False
actorAbsolute=self.server.httpPrefix+'://'+self.server.domainFull+actor
self._redirect_headers(actorAbsolute+'/'+timelineStr+'?page='+ \
str(pageNumber)+ \
timelineBookmark,cookie)
return
self._benchmarkGETtimings(GETstartTime,GETtimings,32)
unrepeatPrivate=False
if htmlGET and '?unrepeatprivate=' in self.path:
unrepeatPrivate=True
self.path=self.path.replace('?unrepeatprivate=','?unrepeat=')
# undo an announce/repeat from the web interface
if htmlGET and '?unrepeat=' in self.path:
pageNumber=1
repeatUrl=self.path.split('?unrepeat=')[1]
if '?' in repeatUrl:
repeatUrl=repeatUrl.split('?')[0]
timelineBookmark=''
if '?bm=' in self.path:
timelineBookmark=self.path.split('?bm=')[1]
if '?' in timelineBookmark:
timelineBookmark=timelineBookmark.split('?')[0]
timelineBookmark='#'+timelineBookmark
if '?page=' in self.path:
pageNumberStr=self.path.split('?page=')[1]
if '?' in pageNumberStr:
pageNumberStr=pageNumberStr.split('?')[0]
if pageNumberStr.isdigit():
pageNumber=int(pageNumberStr)
timelineStr='inbox'
if '?tl=' in self.path:
timelineStr=self.path.split('?tl=')[1]
if '?' in timelineStr:
timelineStr=timelineStr.split('?')[0]
actor=self.path.split('?unrepeat=')[0]
self.postToNickname=getNicknameFromActor(actor)
if not self.postToNickname:
print('WARN: unable to find nickname in '+actor)
self.server.GETbusy=False
actorAbsolute=self.server.httpPrefix+'://'+self.server.domainFull+actor
self._redirect_headers(actorAbsolute+'/'+timelineStr+'?page='+ \
str(pageNumber),cookie)
return
if not self.server.session:
self.server.session= \
createSession(self.server.useTor)
undoAnnounceActor= \
self.server.httpPrefix+'://'+self.server.domainFull+ \
'/users/'+self.postToNickname
unRepeatToStr='https://www.w3.org/ns/activitystreams#Public'
newUndoAnnounce = {
"@context": "https://www.w3.org/ns/activitystreams",
'actor': undoAnnounceActor,
'type': 'Undo',
'cc': [undoAnnounceActor+'/followers'],
'to': [unRepeatToStr],
'object': {
'actor': undoAnnounceActor,
'cc': [undoAnnounceActor+'/followers'],
'object': repeatUrl,
'to': [unRepeatToStr],
'type': 'Announce'
}
}
self._postToOutboxThread(newUndoAnnounce)
self.server.GETbusy=False
actorAbsolute=self.server.httpPrefix+'://'+self.server.domainFull+actor
self._redirect_headers(actorAbsolute+'/'+timelineStr+'?page='+ \
str(pageNumber)+ \
timelineBookmark,cookie)
return
self._benchmarkGETtimings(GETstartTime,GETtimings,33)
# send a follow request approval from the web interface
if authorized and '/followapprove=' in self.path and \
self.path.startswith('/users/'):
originPathStr=self.path.split('/followapprove=')[0]
followerNickname=originPathStr.replace('/users/','')
followingHandle=self.path.split('/followapprove=')[1]
if '@' in followingHandle:
if not self.server.session:
self.server.session= \
createSession(self.server.useTor)
manualApproveFollowRequest(self.server.session, \
self.server.baseDir, \
self.server.httpPrefix, \
followerNickname, \
self.server.domain, \
self.server.port, \
followingHandle, \
self.server.federationList, \
self.server.sendThreads, \
self.server.postLog, \
self.server.cachedWebfingers, \
self.server.personCache, \
self.server.acceptedCaps, \
self.server.debug, \
self.server.projectVersion)
originPathStrAbsolute=self.server.httpPrefix+'://'+self.server.domainFull+originPathStr
self._redirect_headers(originPathStrAbsolute,cookie)
self.server.GETbusy=False
return
self._benchmarkGETtimings(GETstartTime,GETtimings,34)
# deny a follow request from the web interface
if authorized and '/followdeny=' in self.path and \
self.path.startswith('/users/'):
originPathStr=self.path.split('/followdeny=')[0]
followerNickname=originPathStr.replace('/users/','')
followingHandle=self.path.split('/followdeny=')[1]
if '@' in followingHandle:
manualDenyFollowRequest(self.server.session, \
self.server.baseDir, \
self.server.httpPrefix, \
followerNickname, \
self.server.domain, \
self.server.port, \
followingHandle, \
self.server.federationList, \
self.server.sendThreads, \
self.server.postLog, \
self.server.cachedWebfingers, \
self.server.personCache, \
self.server.debug, \
self.server.projectVersion)
originPathStrAbsolute=self.server.httpPrefix+'://'+self.server.domainFull+originPathStr
self._redirect_headers(originPathStrAbsolute,cookie)
self.server.GETbusy=False
return
self._benchmarkGETtimings(GETstartTime,GETtimings,35)
# like from the web interface icon
if htmlGET and '?like=' in self.path:
pageNumber=1
likeUrl=self.path.split('?like=')[1]
if '?' in likeUrl:
likeUrl=likeUrl.split('?')[0]
timelineBookmark=''
if '?bm=' in self.path:
timelineBookmark=self.path.split('?bm=')[1]
if '?' in timelineBookmark:
timelineBookmark=timelineBookmark.split('?')[0]
timelineBookmark='#'+timelineBookmark
actor=self.path.split('?like=')[0]
if '?page=' in self.path:
pageNumberStr=self.path.split('?page=')[1]
if '?' in pageNumberStr:
pageNumberStr=pageNumberStr.split('?')[0]
if pageNumberStr.isdigit():
pageNumber=int(pageNumberStr)
timelineStr='inbox'
if '?tl=' in self.path:
timelineStr=self.path.split('?tl=')[1]
if '?' in timelineStr:
timelineStr=timelineStr.split('?')[0]
self.postToNickname=getNicknameFromActor(actor)
if not self.postToNickname:
print('WARN: unable to find nickname in '+actor)
self.server.GETbusy=False
actorAbsolute=self.server.httpPrefix+'://'+self.server.domainFull+actor
self._redirect_headers(actorAbsolute+'/'+timelineStr+ \
'?page='+str(pageNumber)+ \
timelineBookmark,cookie)
return
if not self.server.session:
self.server.session= \
createSession(self.server.useTor)
likeActor= \
self.server.httpPrefix+'://'+ \
self.server.domainFull+'/users/'+self.postToNickname
actorLiked=self.path.split('?actor=')[1]
if '?' in actorLiked:
actorLiked=actorLiked.split('?')[0]
likeJson= {
"@context": "https://www.w3.org/ns/activitystreams",
'type': 'Like',
'actor': likeActor,
'to': [actorLiked],
'object': likeUrl
}
self._postToOutbox(likeJson,self.server.projectVersion)
self.server.GETbusy=False
actorAbsolute=self.server.httpPrefix+'://'+self.server.domainFull+actor
self._redirect_headers(actorAbsolute+'/'+timelineStr+ \
'?page='+str(pageNumber)+ \
timelineBookmark,cookie)
return
self._benchmarkGETtimings(GETstartTime,GETtimings,36)
# undo a like from the web interface icon
if htmlGET and '?unlike=' in self.path:
pageNumber=1
likeUrl=self.path.split('?unlike=')[1]
if '?' in likeUrl:
likeUrl=likeUrl.split('?')[0]
timelineBookmark=''
if '?bm=' in self.path:
timelineBookmark=self.path.split('?bm=')[1]
if '?' in timelineBookmark:
timelineBookmark=timelineBookmark.split('?')[0]
timelineBookmark='#'+timelineBookmark
if '?page=' in self.path:
pageNumberStr=self.path.split('?page=')[1]
if '?' in pageNumberStr:
pageNumberStr=pageNumberStr.split('?')[0]
if pageNumberStr.isdigit():
pageNumber=int(pageNumberStr)
timelineStr='inbox'
if '?tl=' in self.path:
timelineStr=self.path.split('?tl=')[1]
if '?' in timelineStr:
timelineStr=timelineStr.split('?')[0]
actor=self.path.split('?unlike=')[0]
self.postToNickname=getNicknameFromActor(actor)
if not self.postToNickname:
print('WARN: unable to find nickname in '+actor)
self.server.GETbusy=False
actorAbsolute=self.server.httpPrefix+'://'+self.server.domainFull+actor
self._redirect_headers(actorAbsolute+'/'+timelineStr+ \
'?page='+str(pageNumber),cookie)
return
if not self.server.session:
self.server.session= \
createSession(self.server.useTor)
undoActor= \
self.server.httpPrefix+'://'+ \
self.server.domainFull+'/users/'+self.postToNickname
actorLiked=self.path.split('?actor=')[1]
if '?' in actorLiked:
actorLiked=actorLiked.split('?')[0]
undoLikeJson= {
"@context": "https://www.w3.org/ns/activitystreams",
'type': 'Undo',
'actor': undoActor,
'to': [actorLiked],
'object': {
'type': 'Like',
'actor': undoActor,
'to': [actorLiked],
'object': likeUrl
}
}
self._postToOutbox(undoLikeJson,self.server.projectVersion)
self.server.GETbusy=False
actorAbsolute=self.server.httpPrefix+'://'+self.server.domainFull+actor
self._redirect_headers(actorAbsolute+'/'+timelineStr+ \
'?page='+str(pageNumber)+ \
timelineBookmark,cookie)
return
self._benchmarkGETtimings(GETstartTime,GETtimings,36)
# bookmark from the web interface icon
if htmlGET and '?bookmark=' in self.path:
pageNumber=1
bookmarkUrl=self.path.split('?bookmark=')[1]
if '?' in bookmarkUrl:
bookmarkUrl=bookmarkUrl.split('?')[0]
timelineBookmark=''
if '?bm=' in self.path:
timelineBookmark=self.path.split('?bm=')[1]
if '?' in timelineBookmark:
timelineBookmark=timelineBookmark.split('?')[0]
timelineBookmark='#'+timelineBookmark
actor=self.path.split('?bookmark=')[0]
if '?page=' in self.path:
pageNumberStr=self.path.split('?page=')[1]
if '?' in pageNumberStr:
pageNumberStr=pageNumberStr.split('?')[0]
if pageNumberStr.isdigit():
pageNumber=int(pageNumberStr)
timelineStr='inbox'
if '?tl=' in self.path:
timelineStr=self.path.split('?tl=')[1]
if '?' in timelineStr:
timelineStr=timelineStr.split('?')[0]
self.postToNickname=getNicknameFromActor(actor)
if not self.postToNickname:
print('WARN: unable to find nickname in '+actor)
self.server.GETbusy=False
actorAbsolute=self.server.httpPrefix+'://'+self.server.domainFull+actor
self._redirect_headers(actorAbsolute+'/'+timelineStr+ \
'?page='+str(pageNumber),cookie)
return
if not self.server.session:
self.server.session= \
createSession(self.server.useTor)
bookmarkActor= \
self.server.httpPrefix+'://'+ \
self.server.domainFull+'/users/'+self.postToNickname
bookmarkJson= {
"@context": "https://www.w3.org/ns/activitystreams",
'type': 'Bookmark',
'actor': bookmarkActor,
'to': [bookmarkActor],
'object': bookmarkUrl
}
self._postToOutbox(bookmarkJson,self.server.projectVersion)
self.server.GETbusy=False
actorAbsolute=self.server.httpPrefix+'://'+self.server.domainFull+actor
self._redirect_headers(actorAbsolute+'/'+timelineStr+ \
'?page='+str(pageNumber)+ \
timelineBookmark,cookie)
return
# undo a bookmark from the web interface icon
if htmlGET and '?unbookmark=' in self.path:
pageNumber=1
bookmarkUrl=self.path.split('?unbookmark=')[1]
if '?' in bookmarkUrl:
bookmarkUrl=bookmarkUrl.split('?')[0]
timelineBookmark=''
if '?bm=' in self.path:
timelineBookmark=self.path.split('?bm=')[1]
if '?' in timelineBookmark:
timelineBookmark=timelineBookmark.split('?')[0]
timelineBookmark='#'+timelineBookmark
if '?page=' in self.path:
pageNumberStr=self.path.split('?page=')[1]
if '?' in pageNumberStr:
pageNumberStr=pageNumberStr.split('?')[0]
if pageNumberStr.isdigit():
pageNumber=int(pageNumberStr)
timelineStr='inbox'
if '?tl=' in self.path:
timelineStr=self.path.split('?tl=')[1]
if '?' in timelineStr:
timelineStr=timelineStr.split('?')[0]
actor=self.path.split('?unbookmark=')[0]
self.postToNickname=getNicknameFromActor(actor)
if not self.postToNickname:
print('WARN: unable to find nickname in '+actor)
self.server.GETbusy=False
actorAbsolute=self.server.httpPrefix+'://'+self.server.domainFull+actor
self._redirect_headers(actorAbsolute+'/'+timelineStr+ \
'?page='+str(pageNumber),cookie)
return
if not self.server.session:
self.server.session= \
createSession(self.server.useTor)
undoActor= \
self.server.httpPrefix+'://'+ \
self.server.domainFull+'/users/'+self.postToNickname
undoBookmarkJson= {
"@context": "https://www.w3.org/ns/activitystreams",
'type': 'Undo',
'actor': undoActor,
'to': [undoActor],
'object': {
'type': 'Bookmark',
'actor': undoActor,
'to': [undoActor],
'object': bookmarkUrl
}
}
self._postToOutbox(undoBookmarkJson,self.server.projectVersion)
self.server.GETbusy=False
actorAbsolute=self.server.httpPrefix+'://'+self.server.domainFull+actor
self._redirect_headers(actorAbsolute+'/'+timelineStr+ \
'?page='+str(pageNumber)+ \
timelineBookmark,cookie)
return
self._benchmarkGETtimings(GETstartTime,GETtimings,37)
# delete a post from the web interface icon
if htmlGET and '?delete=' in self.path:
pageNumber=1
if '?page=' in self.path:
pageNumberStr=self.path.split('?page=')[1]
if '?' in pageNumberStr:
pageNumberStr=pageNumberStr.split('?')[0]
if pageNumberStr.isdigit():
pageNumber=int(pageNumberStr)
deleteUrl=self.path.split('?delete=')[1]
if '?' in deleteUrl:
deleteUrl=deleteUrl.split('?')[0]
timelineStr=self.server.defaultTimeline
if '?tl=' in self.path:
timelineStr=self.path.split('?tl=')[1]
if '?' in timelineStr:
timelineStr=timelineStr.split('?')[0]
actor= \
self.server.httpPrefix+'://'+ \
self.server.domainFull+self.path.split('?delete=')[0]
if self.server.allowDeletion or \
deleteUrl.startswith(actor):
if self.server.debug:
print('DEBUG: deleteUrl='+deleteUrl)
print('DEBUG: actor='+actor)
if actor not in deleteUrl:
# You can only delete your own posts
self.server.GETbusy=False
self._redirect_headers(actor+'/'+timelineStr,cookie)
return
self.postToNickname=getNicknameFromActor(actor)
if not self.postToNickname:
print('WARN: unable to find nickname in '+actor)
self.server.GETbusy=False
self._redirect_headers(actor+'/'+timelineStr,cookie)
return
if not self.server.session:
self.server.session= \
createSession(self.server.useTor)
deleteStr= \
htmlDeletePost(self.server.recentPostsCache, \
self.server.maxRecentPosts, \
self.server.translate,pageNumber, \
self.server.session,self.server.baseDir, \
deleteUrl,self.server.httpPrefix, \
__version__,self.server.cachedWebfingers, \
self.server.personCache)
if deleteStr:
self._set_headers('text/html',len(deleteStr),cookie)
self._write(deleteStr.encode())
self.server.GETbusy=False
return
self.server.GETbusy=False
self._redirect_headers(actor+'/'+timelineStr,cookie)
return
# mute a post from the web interface icon
if htmlGET and '?mute=' in self.path:
pageNumber=1
if '?page=' in self.path:
pageNumberStr=self.path.split('?page=')[1]
if '?' in pageNumberStr:
pageNumberStr=pageNumberStr.split('?')[0]
if pageNumberStr.isdigit():
pageNumber=int(pageNumberStr)
muteUrl=self.path.split('?mute=')[1]
if '?' in muteUrl:
muteUrl=muteUrl.split('?')[0]
timelineBookmark=''
if '?bm=' in self.path:
timelineBookmark=self.path.split('?bm=')[1]
if '?' in timelineBookmark:
timelineBookmark=timelineBookmark.split('?')[0]
timelineBookmark='#'+timelineBookmark
timelineStr=self.server.defaultTimeline
if '?tl=' in self.path:
timelineStr=self.path.split('?tl=')[1]
if '?' in timelineStr:
timelineStr=timelineStr.split('?')[0]
actor= \
self.server.httpPrefix+'://'+ \
self.server.domainFull+self.path.split('?mute=')[0]
nickname=getNicknameFromActor(actor)
mutePost(self.server.baseDir,nickname,self.server.domain, \
muteUrl,self.server.recentPostsCache)
self.server.GETbusy=False
self._redirect_headers(actor+'/'+timelineStr+timelineBookmark,cookie)
return
# unmute a post from the web interface icon
if htmlGET and '?unmute=' in self.path:
pageNumber=1
if '?page=' in self.path:
pageNumberStr=self.path.split('?page=')[1]
if '?' in pageNumberStr:
pageNumberStr=pageNumberStr.split('?')[0]
if pageNumberStr.isdigit():
pageNumber=int(pageNumberStr)
muteUrl=self.path.split('?unmute=')[1]
if '?' in muteUrl:
muteUrl=muteUrl.split('?')[0]
timelineBookmark=''
if '?bm=' in self.path:
timelineBookmark=self.path.split('?bm=')[1]
if '?' in timelineBookmark:
timelineBookmark=timelineBookmark.split('?')[0]
timelineBookmark='#'+timelineBookmark
timelineStr=self.server.defaultTimeline
if '?tl=' in self.path:
timelineStr=self.path.split('?tl=')[1]
if '?' in timelineStr:
timelineStr=timelineStr.split('?')[0]
actor= \
self.server.httpPrefix+'://'+ \
self.server.domainFull+self.path.split('?unmute=')[0]
nickname=getNicknameFromActor(actor)
unmutePost(self.server.baseDir,nickname,self.server.domain, \
muteUrl,self.server.recentPostsCache)
self.server.GETbusy=False
self._redirect_headers(actor+'/'+timelineStr+timelineBookmark,cookie)
return
# reply from the web interface icon
inReplyToUrl=None
replyWithDM=False
replyToList=[]
replyPageNumber=1
shareDescription=None
replytoActor=None
if htmlGET:
# public reply
if '?replyto=' in self.path:
inReplyToUrl=self.path.split('?replyto=')[1]
if '?' in inReplyToUrl:
mentionsList=inReplyToUrl.split('?')
for m in mentionsList:
if m.startswith('mention='):
replyHandle=m.replace('mention=','')
if replyHandle not in replyToList:
replyToList.append(replyHandle)
if m.startswith('page='):
replyPageStr=m.replace('page=','')
if replyPageStr.isdigit():
replyPageNumber=int(replyPageStr)
if m.startswith('actor='):
replytoActor=m.replace('actor=','')
inReplyToUrl=mentionsList[0]
self.path=self.path.split('?replyto=')[0]+'/newpost'
if self.server.debug:
print('DEBUG: replyto path '+self.path)
# reply to followers
if '?replyfollowers=' in self.path:
inReplyToUrl=self.path.split('?replyfollowers=')[1]
if '?' in inReplyToUrl:
mentionsList=inReplyToUrl.split('?')
for m in mentionsList:
if m.startswith('mention='):
replyHandle=m.replace('mention=','')
if m.replace('mention=','') not in replyToList:
replyToList.append(replyHandle)
if m.startswith('page='):
replyPageStr=m.replace('page=','')
if replyPageStr.isdigit():
replyPageNumber=int(replyPageStr)
if m.startswith('actor='):
replytoActor=m.replace('actor=','')
inReplyToUrl=mentionsList[0]
self.path=self.path.split('?replyfollowers=')[0]+'/newfollowers'
if self.server.debug:
print('DEBUG: replyfollowers path '+self.path)
# replying as a direct message, for moderation posts or the dm timeline
if '?replydm=' in self.path:
inReplyToUrl=self.path.split('?replydm=')[1]
if '?' in inReplyToUrl:
mentionsList=inReplyToUrl.split('?')
for m in mentionsList:
if m.startswith('mention='):
replyHandle=m.replace('mention=','')
if m.replace('mention=','') not in replyToList:
replyToList.append(m.replace('mention=',''))
if m.startswith('page='):
replyPageStr=m.replace('page=','')
if replyPageStr.isdigit():
replyPageNumber=int(replyPageStr)
if m.startswith('actor='):
replytoActor=m.replace('actor=','')
inReplyToUrl=mentionsList[0]
if inReplyToUrl.startswith('sharedesc:'):
shareDescription= \
inReplyToUrl.replace('sharedesc:','').replace('%20',' ').replace('%40','@').replace('%3A',':').replace('%2F','/').replace('%23','#')
self.path=self.path.split('?replydm=')[0]+'/newdm'
if self.server.debug:
print('DEBUG: replydm path '+self.path)
# edit profile in web interface
if '/users/' in self.path and self.path.endswith('/editprofile'):
msg=htmlEditProfile(self.server.translate, \
self.server.baseDir, \
self.path,self.server.domain, \
self.server.port, \
self.server.httpPrefix).encode()
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
self.server.GETbusy=False
return
# Various types of new post in the web interface
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('/newreport') or \
self.path.endswith('/newquestion') or \
self.path.endswith('/newshare')):
nickname=getNicknameFromActor(self.path)
msg=htmlNewPost(self.server.mediaInstance, \
self.server.translate, \
self.server.baseDir, \
self.server.httpPrefix, \
self.path,inReplyToUrl, \
replyToList, \
shareDescription, \
replyPageNumber, \
nickname,self.server.domain).encode()
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
self.server.GETbusy=False
return
self._benchmarkGETtimings(GETstartTime,GETtimings,38)
# get an individual post from the path /@nickname/statusnumber
if '/@' in self.path:
namedStatus=self.path.split('/@')[1]
if '/' not in namedStatus:
# show actor
nickname=namedStatus
else:
postSections=namedStatus.split('/')
if len(postSections)==2:
nickname=postSections[0]
statusNumber=postSections[1]
if len(statusNumber)>10 and statusNumber.isdigit():
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=loadJson(postFilename)
loadedPost=False
if postJsonObject:
loadedPost=True
else:
postJsonObject={}
if loadedPost:
# Only authorized viewers get to see likes on posts
# Otherwize marketers could gain more social graph info
if not authorized:
self._removePostInteractions(postJsonObject)
if self._requestHTTP():
msg= \
htmlIndividualPost(self.server.recentPostsCache, \
self.server.maxRecentPosts, \
self.server.translate, \
self.server.session, \
self.server.cachedWebfingers, \
self.server.personCache, \
nickname,self.server.domain, \
self.server.port, \
authorized,postJsonObject, \
self.server.httpPrefix, \
self.server.projectVersion).encode('utf-8')
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
else:
if self._fetchAuthenticated():
msg=json.dumps(postJsonObject,ensure_ascii=False).encode('utf-8')
self._set_headers('application/json',len(msg),None)
self._write(msg)
else:
self._404()
self.server.GETbusy=False
return
else:
self._404()
self.server.GETbusy=False
return
self._benchmarkGETtimings(GETstartTime,GETtimings,39)
# get replies to a post /users/nickname/statuses/number/replies
if self.path.endswith('/replies') or '/replies?page=' in self.path:
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
boxname='outbox'
postDir= \
self.server.baseDir+'/accounts/'+ \
nickname+'@'+self.server.domain+'/'+boxname
postRepliesFilename= \
postDir+'/'+ \
self.server.httpPrefix+':##'+ \
self.server.domainFull+'#users#'+ \
nickname+'#statuses#'+statusNumber+'.replies'
if not os.path.isfile(postRepliesFilename):
# There are no replies, so show empty collection
repliesJson = {
'@context': 'https://www.w3.org/ns/activitystreams',
'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',
'totalItems': 0,
'type': 'OrderedCollection'}
if self._requestHTTP():
if not self.server.session:
if self.server.debug:
print('DEBUG: creating new session')
self.server.session= \
createSession(self.server.useTor)
msg=htmlPostReplies(self.server.recentPostsCache, \
self.server.maxRecentPosts, \
self.server.translate, \
self.server.baseDir, \
self.server.session, \
self.server.cachedWebfingers, \
self.server.personCache, \
nickname, \
self.server.domain, \
self.server.port, \
repliesJson, \
self.server.httpPrefix, \
self.server.projectVersion).encode('utf-8')
self._set_headers('text/html',len(msg),cookie)
print('----------------------------------------------------')
self._write(msg)
else:
if self._fetchAuthenticated():
msg=json.dumps(repliesJson,ensure_ascii=False).encode('utf-8')
self._set_headers('application/json',len(msg),None)
self._write(msg)
else:
self._404()
self.server.GETbusy=False
return
else:
# replies exist. Itterate through the text file containing message ids
repliesJson = {
'@context': 'https://www.w3.org/ns/activitystreams',
'id': self.server.httpPrefix+'://'+self.server.domainFull+'/users/'+nickname+'/statuses/'+statusNumber+'?page=true',
'orderedItems': [
],
'partOf': self.server.httpPrefix+'://'+self.server.domainFull+'/users/'+nickname+'/statuses/'+statusNumber,
'type': 'OrderedCollectionPage'}
# populate the items list with replies
populateRepliesJson(self.server.baseDir, \
nickname, \
self.server.domain, \
postRepliesFilename, \
authorized, \
repliesJson)
# send the replies json
if self._requestHTTP():
if not self.server.session:
if self.server.debug:
print('DEBUG: creating new session')
self.server.session= \
createSession(self.server.useTor)
msg=htmlPostReplies(self.server.recentPostsCache, \
self.server.maxRecentPosts, \
self.server.translate, \
self.server.baseDir, \
self.server.session, \
self.server.cachedWebfingers, \
self.server.personCache, \
nickname, \
self.server.domain, \
self.server.port, \
repliesJson, \
self.server.httpPrefix, \
self.server.projectVersion).encode('utf-8')
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
else:
if self._fetchAuthenticated():
msg=json.dumps(repliesJson,ensure_ascii=False).encode('utf-8')
self._set_headers('application/json',len(msg),None)
self._write(msg)
else:
self._404()
self.server.GETbusy=False
return
self._benchmarkGETtimings(GETstartTime,GETtimings,40)
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):
actorJson=loadJson(actorFilename)
if actorJson:
if actorJson.get('roles'):
if self._requestHTTP():
getPerson = \
personLookup(self.server.domain, \
self.path.replace('/roles',''), \
self.server.baseDir)
if getPerson:
msg=htmlProfile(self.server.defaultTimeline, \
self.server.recentPostsCache, \
self.server.maxRecentPosts, \
self.server.translate, \
self.server.projectVersion, \
self.server.baseDir, \
self.server.httpPrefix, \
True, \
self.server.ocapAlways, \
getPerson,'roles', \
self.server.session, \
self.server.cachedWebfingers, \
self.server.personCache, \
actorJson['roles'], \
None,None).encode('utf-8')
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
else:
if self._fetchAuthenticated():
msg=json.dumps(actorJson['roles'],ensure_ascii=False).encode('utf-8')
self._set_headers('application/json',len(msg),None)
self._write(msg)
else:
self._404()
self.server.GETbusy=False
return
# show skills on the profile page
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):
actorJson=loadJson(actorFilename)
if actorJson:
if actorJson.get('skills'):
if self._requestHTTP():
getPerson = \
personLookup(self.server.domain, \
self.path.replace('/skills',''), \
self.server.baseDir)
if getPerson:
msg=htmlProfile(self.server.defaultTimeline, \
self.server.recentPostsCache, \
self.server.maxRecentPosts, \
self.server.translate, \
self.server.projectVersion, \
self.server.baseDir, \
self.server.httpPrefix, \
True, \
self.server.ocapAlways, \
getPerson,'skills', \
self.server.session, \
self.server.cachedWebfingers, \
self.server.personCache, \
actorJson['skills'], \
None,None).encode('utf-8')
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
else:
if self._fetchAuthenticated():
msg=json.dumps(actorJson['skills'],ensure_ascii=False).encode('utf-8')
self._set_headers('application/json',len(msg),None)
self._write(msg)
else:
self._404()
self.server.GETbusy=False
return
actor=self.path.replace('/skills','')
actorAbsolute=self.server.httpPrefix+'://'+self.server.domainFull+actor
self._redirect_headers(actorAbsolute,cookie)
self.server.GETbusy=False
return
self._benchmarkGETtimings(GETstartTime,GETtimings,41)
# get an individual post from the path /users/nickname/statuses/number
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)>=3:
nickname=postSections[0]
statusNumber=postSections[2]
if len(statusNumber)>10 and statusNumber.isdigit():
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=loadJson(postFilename)
if not postJsonObject:
self.send_response(429)
self.end_headers()
self.server.GETbusy=False
return
else:
# Only authorized viewers get to see likes on posts
# Otherwize marketers could gain more social graph info
if not authorized:
self._removePostInteractions(postJsonObject)
if self._requestHTTP():
msg=htmlIndividualPost(self.server.recentPostsCache, \
self.server.maxRecentPosts, \
self.server.translate, \
self.server.baseDir, \
self.server.session, \
self.server.cachedWebfingers, \
self.server.personCache, \
nickname, \
self.server.domain, \
self.server.port, \
authorized,postJsonObject, \
self.server.httpPrefix, \
self.server.projectVersion).encode('utf-8')
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
else:
if self._fetchAuthenticated():
msg=json.dumps(postJsonObject,ensure_ascii=False).encode('utf-8')
self._set_headers('application/json',len(msg),None)
self._write(msg)
else:
self._404()
self.server.GETbusy=False
return
else:
self._404()
self.server.GETbusy=False
return
self._benchmarkGETtimings(GETstartTime,GETtimings,42)
# get the inbox for a given person
if self.path.endswith('/inbox') or '/inbox?page=' in self.path:
if '/users/' in self.path:
if authorized:
inboxFeed= \
personBoxJson(self.server.recentPostsCache, \
self.server.session, \
self.server.baseDir, \
self.server.domain, \
self.server.port, \
self.path, \
self.server.httpPrefix, \
maxPostsInFeed, 'inbox', \
authorized,self.server.ocapAlways)
if inboxFeed:
if self._requestHTTP():
nickname=self.path.replace('/users/','').replace('/inbox','')
pageNumber=1
if '?page=' in nickname:
pageNumber=nickname.split('?page=')[1]
nickname=nickname.split('?page=')[0]
if pageNumber.isdigit():
pageNumber=int(pageNumber)
else:
pageNumber=1
if 'page=' not in self.path:
# if no page was specified then show the first
inboxFeed= \
personBoxJson(self.server.recentPostsCache, \
self.server.session, \
self.server.baseDir, \
self.server.domain, \
self.server.port, \
self.path+'?page=1', \
self.server.httpPrefix, \
maxPostsInFeed, 'inbox', \
authorized,self.server.ocapAlways)
msg=htmlInbox(self.server.defaultTimeline, \
self.server.recentPostsCache, \
self.server.maxRecentPosts, \
self.server.translate, \
pageNumber,maxPostsInFeed, \
self.server.session, \
self.server.baseDir, \
self.server.cachedWebfingers, \
self.server.personCache, \
nickname, \
self.server.domain, \
self.server.port, \
inboxFeed, \
self.server.allowDeletion, \
self.server.httpPrefix, \
self.server.projectVersion).encode('utf-8')
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
else:
# don't need authenticated fetch here because there is
# already the authorization check
msg=json.dumps(inboxFeed,ensure_ascii=False).encode('utf-8')
self._set_headers('application/json',len(msg),None)
self._write(msg)
self.server.GETbusy=False
return
else:
if self.server.debug:
nickname=self.path.replace('/users/','').replace('/inbox','')
print('DEBUG: '+nickname+ \
' was not authorized to access '+self.path)
if self.path!='/inbox':
# not the shared inbox
if self.server.debug:
print('DEBUG: GET access to inbox is unauthorized')
self.send_response(405)
self.end_headers()
self.server.GETbusy=False
return
self._benchmarkGETtimings(GETstartTime,GETtimings,43)
# get the direct messages for a given person
if self.path.endswith('/dm') or '/dm?page=' in self.path:
if '/users/' in self.path:
if authorized:
inboxDMFeed= \
personBoxJson(self.server.recentPostsCache, \
self.server.session, \
self.server.baseDir, \
self.server.domain, \
self.server.port, \
self.path, \
self.server.httpPrefix, \
maxPostsInFeed, 'dm', \
authorized,self.server.ocapAlways)
if inboxDMFeed:
if self._requestHTTP():
nickname=self.path.replace('/users/','').replace('/dm','')
pageNumber=1
if '?page=' in nickname:
pageNumber=nickname.split('?page=')[1]
nickname=nickname.split('?page=')[0]
if pageNumber.isdigit():
pageNumber=int(pageNumber)
else:
pageNumber=1
if 'page=' not in self.path:
# if no page was specified then show the first
inboxDMFeed= \
personBoxJson(self.server.recentPostsCache, \
self.server.session, \
self.server.baseDir, \
self.server.domain, \
self.server.port, \
self.path+'?page=1', \
self.server.httpPrefix, \
maxPostsInFeed, 'dm', \
authorized,self.server.ocapAlways)
msg=htmlInboxDMs(self.server.defaultTimeline, \
self.server.recentPostsCache, \
self.server.maxRecentPosts, \
self.server.translate, \
pageNumber,maxPostsInFeed, \
self.server.session, \
self.server.baseDir, \
self.server.cachedWebfingers, \
self.server.personCache, \
nickname, \
self.server.domain, \
self.server.port, \
inboxDMFeed, \
self.server.allowDeletion, \
self.server.httpPrefix, \
self.server.projectVersion).encode('utf-8')
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
else:
# don't need authenticated fetch here because there is
# already the authorization check
msg=json.dumps(inboxDMFeed,ensure_ascii=False).encode('utf-8')
self._set_headers('application/json',len(msg),None)
self._write(msg)
self.server.GETbusy=False
return
else:
if self.server.debug:
nickname=self.path.replace('/users/','').replace('/dm','')
print('DEBUG: '+nickname+ \
' was not authorized to access '+self.path)
if self.path!='/dm':
# not the DM inbox
if self.server.debug:
print('DEBUG: GET access to inbox is unauthorized')
self.send_response(405)
self.end_headers()
self.server.GETbusy=False
return
self._benchmarkGETtimings(GETstartTime,GETtimings,44)
# get the replies for a given person
if self.path.endswith('/tlreplies') or '/tlreplies?page=' in self.path:
if '/users/' in self.path:
if authorized:
inboxRepliesFeed= \
personBoxJson(self.server.recentPostsCache, \
self.server.session, \
self.server.baseDir, \
self.server.domain, \
self.server.port, \
self.path, \
self.server.httpPrefix, \
maxPostsInFeed, 'tlreplies', \
True,self.server.ocapAlways)
if not inboxRepliesFeed:
inboxRepliesFeed=[]
if self._requestHTTP():
nickname=self.path.replace('/users/','').replace('/tlreplies','')
pageNumber=1
if '?page=' in nickname:
pageNumber=nickname.split('?page=')[1]
nickname=nickname.split('?page=')[0]
if pageNumber.isdigit():
pageNumber=int(pageNumber)
else:
pageNumber=1
if 'page=' not in self.path:
# if no page was specified then show the first
inboxRepliesFeed= \
personBoxJson(self.server.recentPostsCache, \
self.server.session, \
self.server.baseDir, \
self.server.domain, \
self.server.port, \
self.path+'?page=1', \
self.server.httpPrefix, \
maxPostsInFeed, 'tlreplies', \
True,self.server.ocapAlways)
msg=htmlInboxReplies(self.server.defaultTimeline, \
self.server.recentPostsCache, \
self.server.maxRecentPosts, \
self.server.translate, \
pageNumber,maxPostsInFeed, \
self.server.session, \
self.server.baseDir, \
self.server.cachedWebfingers, \
self.server.personCache, \
nickname, \
self.server.domain, \
self.server.port, \
inboxRepliesFeed, \
self.server.allowDeletion, \
self.server.httpPrefix, \
self.server.projectVersion).encode('utf-8')
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
else:
# don't need authenticated fetch here because there is
# already the authorization check
msg=json.dumps(inboxRepliesFeed,ensure_ascii=False).encode('utf-8')
self._set_headers('application/json',len(msg),None)
self._write(msg)
self.server.GETbusy=False
return
else:
if self.server.debug:
nickname=self.path.replace('/users/','').replace('/tlreplies','')
print('DEBUG: '+nickname+ \
' was not authorized to access '+self.path)
if self.path!='/tlreplies':
# not the replies inbox
if self.server.debug:
print('DEBUG: GET access to inbox is unauthorized')
self.send_response(405)
self.end_headers()
self.server.GETbusy=False
return
self._benchmarkGETtimings(GETstartTime,GETtimings,45)
# get the media for a given person
if self.path.endswith('/tlmedia') or '/tlmedia?page=' in self.path:
if '/users/' in self.path:
if authorized:
inboxMediaFeed= \
personBoxJson(self.server.recentPostsCache, \
self.server.session, \
self.server.baseDir, \
self.server.domain, \
self.server.port, \
self.path, \
self.server.httpPrefix, \
maxPostsInMediaFeed, 'tlmedia', \
True,self.server.ocapAlways)
if not inboxMediaFeed:
inboxMediaFeed=[]
if self._requestHTTP():
nickname=self.path.replace('/users/','').replace('/tlmedia','')
pageNumber=1
if '?page=' in nickname:
pageNumber=nickname.split('?page=')[1]
nickname=nickname.split('?page=')[0]
if pageNumber.isdigit():
pageNumber=int(pageNumber)
else:
pageNumber=1
if 'page=' not in self.path:
# if no page was specified then show the first
inboxMediaFeed= \
personBoxJson(self.server.recentPostsCache, \
self.server.session, \
self.server.baseDir, \
self.server.domain, \
self.server.port, \
self.path+'?page=1', \
self.server.httpPrefix, \
maxPostsInMediaFeed, 'tlmedia', \
True,self.server.ocapAlways)
msg=htmlInboxMedia(self.server.defaultTimeline, \
self.server.recentPostsCache, \
self.server.maxRecentPosts, \
self.server.translate, \
pageNumber,maxPostsInMediaFeed, \
self.server.session, \
self.server.baseDir, \
self.server.cachedWebfingers, \
self.server.personCache, \
nickname, \
self.server.domain, \
self.server.port, \
inboxMediaFeed, \
self.server.allowDeletion, \
self.server.httpPrefix, \
self.server.projectVersion).encode('utf-8')
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
else:
# don't need authenticated fetch here because there is
# already the authorization check
msg=json.dumps(inboxMediaFeed,ensure_ascii=False).encode('utf-8')
self._set_headers('application/json',len(msg),None)
self._write(msg)
self.server.GETbusy=False
return
else:
if self.server.debug:
nickname=self.path.replace('/users/','').replace('/tlmedia','')
print('DEBUG: '+nickname+ \
' was not authorized to access '+self.path)
if self.path!='/tlmedia':
# not the media inbox
if self.server.debug:
print('DEBUG: GET access to inbox is unauthorized')
self.send_response(405)
self.end_headers()
self.server.GETbusy=False
return
self._benchmarkGETtimings(GETstartTime,GETtimings,46)
# get the shared items timeline for a given person
if self.path.endswith('/tlshares') or '/tlshares?page=' in self.path:
if '/users/' in self.path:
if authorized:
if self._requestHTTP():
nickname=self.path.replace('/users/','').replace('/tlshares','')
pageNumber=1
if '?page=' in nickname:
pageNumber=nickname.split('?page=')[1]
nickname=nickname.split('?page=')[0]
if pageNumber.isdigit():
pageNumber=int(pageNumber)
else:
pageNumber=1
msg=htmlShares(self.server.defaultTimeline, \
self.server.recentPostsCache, \
self.server.maxRecentPosts, \
self.server.translate, \
pageNumber,maxPostsInFeed, \
self.server.session, \
self.server.baseDir, \
self.server.cachedWebfingers, \
self.server.personCache, \
nickname, \
self.server.domain, \
self.server.port, \
self.server.allowDeletion, \
self.server.httpPrefix, \
self.server.projectVersion).encode('utf-8')
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
self.server.GETbusy=False
return
# not the shares timeline
if self.server.debug:
print('DEBUG: GET access to shares timeline is unauthorized')
self.send_response(405)
self.end_headers()
self.server.GETbusy=False
return
# get the bookmarks for a given person
if self.path.endswith('/tlbookmarks') or '/tlbookmarks?page=' in self.path:
if '/users/' in self.path:
if authorized:
bookmarksFeed= \
personBoxJson(self.server.recentPostsCache, \
self.server.session, \
self.server.baseDir, \
self.server.domain, \
self.server.port, \
self.path, \
self.server.httpPrefix, \
maxPostsInFeed, 'tlbookmarks', \
authorized,self.server.ocapAlways)
if bookmarksFeed:
if self._requestHTTP():
nickname=self.path.replace('/users/','').replace('/tlbookmarks','')
pageNumber=1
if '?page=' in nickname:
pageNumber=nickname.split('?page=')[1]
nickname=nickname.split('?page=')[0]
if pageNumber.isdigit():
pageNumber=int(pageNumber)
else:
pageNumber=1
if 'page=' not in self.path:
# if no page was specified then show the first
bookmarksFeed= \
personBoxJson(self.server.recentPostsCache, \
self.server.session, \
self.server.baseDir, \
self.server.domain, \
self.server.port, \
self.path+'?page=1', \
self.server.httpPrefix, \
maxPostsInFeed, 'tlbookmarks', \
authorized,self.server.ocapAlways)
msg=htmlBookmarks(self.server.defaultTimeline, \
self.server.recentPostsCache, \
self.server.maxRecentPosts, \
self.server.translate, \
pageNumber,maxPostsInFeed, \
self.server.session, \
self.server.baseDir, \
self.server.cachedWebfingers, \
self.server.personCache, \
nickname, \
self.server.domain, \
self.server.port, \
bookmarksFeed, \
self.server.allowDeletion, \
self.server.httpPrefix, \
self.server.projectVersion).encode('utf-8')
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
else:
# don't need authenticated fetch here because there is
# already the authorization check
msg=json.dumps(inboxFeed,ensure_ascii=False).encode('utf-8')
self._set_headers('application/json',len(msg),None)
self._write(msg)
self.server.GETbusy=False
return
else:
if self.server.debug:
nickname=self.path.replace('/users/','').replace('/tlbookmarks','')
print('DEBUG: '+nickname+ \
' was not authorized to access '+self.path)
if self.server.debug:
print('DEBUG: GET access to bookmarks is unauthorized')
self.send_response(405)
self.end_headers()
self.server.GETbusy=False
return
self._benchmarkGETtimings(GETstartTime,GETtimings,47)
# get outbox feed for a person
outboxFeed= \
personBoxJson(self.server.recentPostsCache, \
self.server.session, \
self.server.baseDir,self.server.domain, \
self.server.port,self.path, \
self.server.httpPrefix, \
maxPostsInFeed, 'outbox', \
authorized, \
self.server.ocapAlways)
if outboxFeed:
if self._requestHTTP():
nickname= \
self.path.replace('/users/','').replace('/outbox','')
pageNumber=1
if '?page=' in nickname:
pageNumber=nickname.split('?page=')[1]
nickname=nickname.split('?page=')[0]
if pageNumber.isdigit():
pageNumber=int(pageNumber)
else:
pageNumber=1
if 'page=' not in self.path:
# if a page wasn't specified then show the first one
outboxFeed= \
personBoxJson(self.server.recentPostsCache, \
self.server.session, \
self.server.baseDir, \
self.server.domain, \
self.server.port, \
self.path+'?page=1', \
self.server.httpPrefix, \
maxPostsInFeed, 'outbox', \
authorized, \
self.server.ocapAlways)
msg=htmlOutbox(self.server.defaultTimeline, \
self.server.recentPostsCache, \
self.server.maxRecentPosts, \
self.server.translate, \
pageNumber,maxPostsInFeed, \
self.server.session, \
self.server.baseDir, \
self.server.cachedWebfingers, \
self.server.personCache, \
nickname, \
self.server.domain, \
self.server.port, \
outboxFeed, \
self.server.allowDeletion, \
self.server.httpPrefix, \
self.server.projectVersion).encode('utf-8')
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
else:
if self._fetchAuthenticated():
msg=json.dumps(outboxFeed,ensure_ascii=False).encode('utf-8')
self._set_headers('application/json',len(msg),None)
self._write(msg)
else:
self._404()
self.server.GETbusy=False
return
self._benchmarkGETtimings(GETstartTime,GETtimings,48)
# get the moderation feed for a moderator
if self.path.endswith('/moderation') or \
'/moderation?page=' in self.path:
if '/users/' in self.path:
if authorized:
moderationFeed= \
personBoxJson(self.server.recentPostsCache, \
self.server.session, \
self.server.baseDir, \
self.server.domain, \
self.server.port, \
self.path, \
self.server.httpPrefix, \
maxPostsInFeed, 'moderation', \
True,self.server.ocapAlways)
if moderationFeed:
if self._requestHTTP():
nickname= \
self.path.replace('/users/','').replace('/moderation','')
pageNumber=1
if '?page=' in nickname:
pageNumber=nickname.split('?page=')[1]
nickname=nickname.split('?page=')[0]
if pageNumber.isdigit():
pageNumber=int(pageNumber)
else:
pageNumber=1
if 'page=' not in self.path:
# if no page was specified then show the first
moderationFeed= \
personBoxJson(self.server.recentPostsCache, \
self.server.session, \
self.server.baseDir, \
self.server.domain, \
self.server.port, \
self.path+'?page=1', \
self.server.httpPrefix, \
maxPostsInFeed, 'moderation', \
True,self.server.ocapAlways)
msg=htmlModeration(self.server.defaultTimeline, \
self.server.recentPostsCache, \
self.server.maxRecentPosts, \
self.server.translate, \
pageNumber,maxPostsInFeed, \
self.server.session, \
self.server.baseDir, \
self.server.cachedWebfingers, \
self.server.personCache, \
nickname, \
self.server.domain, \
self.server.port, \
moderationFeed, \
True, \
self.server.httpPrefix, \
self.server.projectVersion).encode('utf-8')
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
else:
# don't need authenticated fetch here because there is
# already the authorization check
msg=json.dumps(moderationFeed,ensure_ascii=False).encode('utf-8')
self._set_headers('application/json',len(msg),None)
self._write(msg)
self.server.GETbusy=False
return
else:
if self.server.debug:
nickname=self.path.replace('/users/','').replace('/moderation','')
print('DEBUG: '+nickname+ \
' was not authorized to access '+self.path)
if self.server.debug:
print('DEBUG: GET access to moderation feed is unauthorized')
self.send_response(405)
self.end_headers()
self.server.GETbusy=False
return
self._benchmarkGETtimings(GETstartTime,GETtimings,49)
shares= \
getSharesFeedForPerson(self.server.baseDir, \
self.server.domain, \
self.server.port,self.path, \
self.server.httpPrefix, \
sharesPerPage)
if shares:
if self._requestHTTP():
pageNumber=1
if '?page=' not in self.path:
searchPath=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)
else:
pageNumberStr=self.path.split('?page=')[1]
if pageNumberStr.isdigit():
pageNumber=int(pageNumberStr)
searchPath=self.path.split('?page=')[0]
getPerson= \
personLookup(self.server.domain, \
searchPath.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.useTor)
msg=htmlProfile(self.server.defaultTimeline, \
self.server.recentPostsCache, \
self.server.maxRecentPosts, \
self.server.translate, \
self.server.projectVersion, \
self.server.baseDir, \
self.server.httpPrefix, \
authorized, \
self.server.ocapAlways, \
getPerson,'shares', \
self.server.session, \
self.server.cachedWebfingers, \
self.server.personCache, \
shares, \
pageNumber,sharesPerPage).encode('utf-8')
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
self.server.GETbusy=False
return
else:
if self._fetchAuthenticated():
msg=json.dumps(shares,ensure_ascii=False).encode('utf-8')
self._set_headers('application/json',len(msg),None)
self._write(msg)
else:
self._404()
self.server.GETbusy=False
return
self._benchmarkGETtimings(GETstartTime,GETtimings,50)
following=getFollowingFeed(self.server.baseDir,self.server.domain, \
self.server.port,self.path, \
self.server.httpPrefix, \
authorized,followsPerPage)
if following:
if self._requestHTTP():
pageNumber=1
if '?page=' not in self.path:
searchPath=self.path
# get a page of following, not the summary
following= \
getFollowingFeed(self.server.baseDir,self.server.domain, \
self.server.port,self.path+'?page=true', \
self.server.httpPrefix, \
authorized,followsPerPage)
else:
pageNumberStr=self.path.split('?page=')[1]
if pageNumberStr.isdigit():
pageNumber=int(pageNumberStr)
searchPath=self.path.split('?page=')[0]
getPerson = personLookup(self.server.domain,searchPath.replace('/following',''), \
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.useTor)
msg=htmlProfile(self.server.defaultTimeline, \
self.server.recentPostsCache, \
self.server.maxRecentPosts, \
self.server.translate, \
self.server.projectVersion, \
self.server.baseDir, \
self.server.httpPrefix, \
authorized, \
self.server.ocapAlways, \
getPerson,'following', \
self.server.session, \
self.server.cachedWebfingers, \
self.server.personCache, \
following, \
pageNumber,followsPerPage).encode('utf-8')
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
self.server.GETbusy=False
return
else:
if self._fetchAuthenticated():
msg=json.dumps(following,ensure_ascii=False).encode('utf-8')
self._set_headers('application/json',len(msg),None)
self._write(msg)
else:
self._404()
self.server.GETbusy=False
return
self._benchmarkGETtimings(GETstartTime,GETtimings,51)
followers= \
getFollowingFeed(self.server.baseDir,self.server.domain, \
self.server.port,self.path, \
self.server.httpPrefix, \
authorized,followsPerPage,'followers')
if followers:
if self._requestHTTP():
pageNumber=1
if '?page=' not in self.path:
searchPath=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')
else:
pageNumberStr=self.path.split('?page=')[1]
if pageNumberStr.isdigit():
pageNumber=int(pageNumberStr)
searchPath=self.path.split('?page=')[0]
getPerson= \
personLookup(self.server.domain,searchPath.replace('/followers',''), \
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.useTor)
msg=htmlProfile(self.server.defaultTimeline, \
self.server.recentPostsCache, \
self.server.maxRecentPosts, \
self.server.translate, \
self.server.projectVersion, \
self.server.baseDir, \
self.server.httpPrefix, \
authorized, \
self.server.ocapAlways, \
getPerson,'followers', \
self.server.session, \
self.server.cachedWebfingers, \
self.server.personCache, \
followers, \
pageNumber,followsPerPage).encode('utf-8')
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
self.server.GETbusy=False
return
else:
if self._fetchAuthenticated():
msg=json.dumps(followers,ensure_ascii=False).encode('utf-8')
self._set_headers('application/json',len(msg),None)
self._write(msg)
else:
self._404()
self.server.GETbusy=False
return
self._benchmarkGETtimings(GETstartTime,GETtimings,52)
# look up a person
getPerson = personLookup(self.server.domain,self.path, \
self.server.baseDir)
if getPerson:
if self._requestHTTP():
if not self.server.session:
if self.server.debug:
print('DEBUG: creating new session')
self.server.session= \
createSession(self.server.useTor)
msg=htmlProfile(self.server.defaultTimeline, \
self.server.recentPostsCache, \
self.server.maxRecentPosts, \
self.server.translate, \
self.server.projectVersion, \
self.server.baseDir, \
self.server.httpPrefix, \
authorized, \
self.server.ocapAlways, \
getPerson,'posts',
self.server.session, \
self.server.cachedWebfingers, \
self.server.personCache, \
None,None).encode('utf-8')
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
else:
if self._fetchAuthenticated():
msg=json.dumps(getPerson,ensure_ascii=False).encode('utf-8')
self._set_headers('application/json',len(msg),None)
self._write(msg)
else:
self._404()
self.server.GETbusy=False
return
self._benchmarkGETtimings(GETstartTime,GETtimings,53)
# check that a json file was requested
if not self.path.endswith('.json'):
if self.server.debug:
print('DEBUG: GET Not json: '+self.path+' '+self.server.baseDir)
self._404()
self.server.GETbusy=False
return
if not self._fetchAuthenticated():
if self.server.debug:
print('WARN: Unauthenticated GET')
self._404()
return
self._benchmarkGETtimings(GETstartTime,GETtimings,54)
# check that the file exists
filename=self.server.baseDir+self.path
if os.path.isfile(filename):
with open(filename, 'r', encoding='utf-8') as File:
content = File.read()
contentJson=json.loads(content)
msg=json.dumps(contentJson,ensure_ascii=False).encode('utf-8')
self._set_headers('application/json',len(msg),None)
self._write(msg)
else:
if self.server.debug:
print('DEBUG: GET Unknown file')
self._404()
self.server.GETbusy=False
self._benchmarkGETtimings(GETstartTime,GETtimings,55)
def do_HEAD(self):
checkPath=self.path
etag=None
fileLength=-1
if '/media/' in self.path:
if self.path.endswith('.png') or \
self.path.endswith('.jpg') or \
self.path.endswith('.gif') or \
self.path.endswith('.webp') or \
self.path.endswith('.mp4') or \
self.path.endswith('.ogv') or \
self.path.endswith('.mp3') or \
self.path.endswith('.ogg'):
mediaStr=self.path.split('/media/')[1]
mediaFilename= \
self.server.baseDir+'/media/'+mediaStr
if os.path.isfile(mediaFilename):
checkPath=mediaFilename
fileLength=os.path.getsize(mediaFilename)
if os.path.isfile(mediaFilename+'.etag'):
try:
with open(mediaFilename+'.etag', 'r') as etagFile:
etag = etagFile.read()
except:
pass
else:
with open(mediaFilename, 'rb') as avFile:
mediaBinary = avFile.read()
etag=sha1(mediaBinary).hexdigest()
try:
with open(mediaFilename+'.etag', 'w') as etagFile:
etagFile.write(etag)
except:
pass
mediaFileType='application/json'
if checkPath.endswith('.png'):
mediaFileType='image/png'
elif checkPath.endswith('.jpg'):
mediaFileType='image/jpeg'
elif checkPath.endswith('.gif'):
mediaFileType='image/gif'
elif checkPath.endswith('.webp'):
mediaFileType='image/webp'
elif checkPath.endswith('.mp4'):
mediaFileType='video/mp4'
elif checkPath.endswith('.ogv'):
mediaFileType='video/ogv'
elif checkPath.endswith('.mp3'):
mediaFileType='audio/mpeg'
elif checkPath.endswith('.ogg'):
mediaFileType='audio/ogg'
self._set_headers_head(mediaFileType,fileLength,etag)
def _receiveNewPostProcess(self,authorized: bool, \
postType: str,path: str,headers: {},
length: int,postBytes,boundary: str) -> int:
# Note: this needs to happen synchronously
# 0 = this is not a new post
# 1 = new post success
# -1 = new post failed
# 2 = new post canceled
if self.server.debug:
print('DEBUG: receiving POST')
if ' boundary=' in headers['Content-Type']:
if self.server.debug:
print('DEBUG: receiving POST headers '+headers['Content-Type'])
nickname=None
nicknameStr=path.split('/users/')[1]
if '/' in nicknameStr:
nickname=nicknameStr.split('/')[0]
else:
return -1
length = int(headers['Content-Length'])
if length>self.server.maxPostLength:
print('POST size too large')
return -1
boundary=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
if self.server.debug:
print('DEBUG: extracting media from POST')
mediaBytes,postBytes=extractMediaInFormPOST(postBytes,boundary,'attachpic')
if self.server.debug:
if mediaBytes:
print('DEBUG: media was found. '+str(len(mediaBytes))+' bytes')
else:
print('DEBUG: no media was found in POST')
# Note: a .temp extension is used here so that at no time is
# an image with metadata publicly exposed, even for a few mS
filenameBase= \
self.server.baseDir+'/accounts/'+ \
nickname+'@'+self.server.domain+'/upload.temp'
filename,attachmentMediaType= \
saveMediaInFormPOST(mediaBytes,self.server.debug,filenameBase)
if self.server.debug:
if filename:
print('DEBUG: POST media filename is '+filename)
else:
print('DEBUG: no media filename in POST')
if filename:
if filename.endswith('.png') or \
filename.endswith('.jpg') or \
filename.endswith('.webp') or \
filename.endswith('.gif'):
if self.server.debug:
print('DEBUG: POST media removing metadata')
postImageFilename=filename.replace('.temp','')
removeMetaData(filename,postImageFilename)
if os.path.isfile(postImageFilename):
print('POST media saved to '+postImageFilename)
else:
print('ERROR: POST media could not be saved to '+postImageFilename)
else:
if os.path.isfile(filename):
os.rename(filename,filename.replace('.temp',''))
fields=extractTextFieldsInPOST(postBytes,boundary,self.server.debug)
if self.server.debug:
if fields:
print('DEBUG: text field extracted from POST '+str(fields))
else:
print('WARN: no text fields could be extracted from POST')
# process the received text fields from the POST
if not fields.get('message') and not fields.get('imageDescription'):
return -1
if fields.get('submitPost'):
if fields['submitPost']!='Submit':
return -1
else:
return 2
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 not fields.get('schedulePost'):
fields['schedulePost']=False
else:
fields['schedulePost']=True
print('DEBUG: shedulePost '+str(fields['schedulePost']))
if not fields.get('eventDate'):
fields['eventDate']=None
if not fields.get('eventTime'):
fields['eventTime']=None
if not fields.get('location'):
fields['location']=None
# Store a file which contains the time in seconds
# since epoch when an attempt to post something was made.
# This is then used for active monthly users counts
lastUsedFilename= \
self.server.baseDir+'/accounts/'+ \
nickname+'@'+self.server.domain+'/.lastUsed'
try:
lastUsedFile=open(lastUsedFilename,'w')
if lastUsedFile:
lastUsedFile.write(str(int(time.time())))
lastUsedFile.close()
except:
pass
if postType=='newpost':
messageJson= \
createPublicPost(self.server.baseDir, \
nickname, \
self.server.domain,self.server.port, \
self.server.httpPrefix, \
fields['message'],False,False,False, \
filename,attachmentMediaType, \
fields['imageDescription'], \
self.server.useBlurHash, \
fields['replyTo'],fields['replyTo'], \
fields['subject'],fields['schedulePost'], \
fields['eventDate'],fields['eventTime'], \
fields['location'])
if messageJson:
if fields['schedulePost']:
return 1
if self._postToOutbox(messageJson,__version__,nickname):
populateReplies(self.server.baseDir, \
self.server.httpPrefix, \
self.server.domainFull, \
messageJson, \
self.server.maxReplies, \
self.server.debug)
return 1
else:
return -1
elif postType=='newunlisted':
messageJson= \
createUnlistedPost(self.server.baseDir, \
nickname, \
self.server.domain,self.server.port, \
self.server.httpPrefix, \
fields['message'],False,False,False, \
filename,attachmentMediaType, \
fields['imageDescription'], \
self.server.useBlurHash, \
fields['replyTo'],fields['replyTo'], \
fields['subject'],fields['schedulePost'], \
fields['eventDate'],fields['eventTime'], \
fields['location'])
if messageJson:
if fields['schedulePost']:
return 1
if self._postToOutbox(messageJson,__version__,nickname):
populateReplies(self.server.baseDir, \
self.server.httpPrefix, \
self.server.domain, \
messageJson, \
self.server.maxReplies, \
self.server.debug)
return 1
else:
return -1
elif postType=='newfollowers':
messageJson= \
createFollowersOnlyPost(self.server.baseDir, \
nickname, \
self.server.domain,self.server.port, \
self.server.httpPrefix, \
fields['message'],True,False,False, \
filename,attachmentMediaType, \
fields['imageDescription'], \
self.server.useBlurHash, \
fields['replyTo'],fields['replyTo'], \
fields['subject'],fields['schedulePost'], \
fields['eventDate'],fields['eventTime'], \
fields['location'])
if messageJson:
if fields['schedulePost']:
return 1
if self._postToOutbox(messageJson,__version__,nickname):
populateReplies(self.server.baseDir, \
self.server.httpPrefix, \
self.server.domain, \
messageJson, \
self.server.maxReplies, \
self.server.debug)
return 1
else:
return -1
elif postType=='newdm':
messageJson=None
print('A DM was posted')
if '@' in fields['message']:
messageJson= \
createDirectMessagePost(self.server.baseDir, \
nickname, \
self.server.domain,self.server.port, \
self.server.httpPrefix, \
fields['message'],True,False,False, \
filename,attachmentMediaType, \
fields['imageDescription'], \
self.server.useBlurHash, \
fields['replyTo'],fields['replyTo'], \
fields['subject'], \
True,fields['schedulePost'], \
fields['eventDate'], \
fields['eventTime'], \
fields['location'])
if messageJson:
if fields['schedulePost']:
return 1
#if self.server.debug:
print('DEBUG: new DM to '+str(messageJson['object']['to']))
if self._postToOutbox(messageJson,__version__,nickname):
populateReplies(self.server.baseDir, \
self.server.httpPrefix, \
self.server.domain, \
messageJson, \
self.server.maxReplies, \
self.server.debug)
return 1
else:
return -1
elif postType=='newreport':
if attachmentMediaType:
if attachmentMediaType!='image':
return -1
# So as to be sure that this only goes to moderators
# and not accounts being reported we disable any
# included fediverse addresses by replacing '@' with '-at-'
fields['message']=fields['message'].replace('@','-at-')
messageJson= \
createReportPost(self.server.baseDir, \
nickname, \
self.server.domain,self.server.port, \
self.server.httpPrefix, \
fields['message'],True,False,False, \
filename,attachmentMediaType, \
fields['imageDescription'], \
self.server.useBlurHash, \
self.server.debug,fields['subject'])
if messageJson:
if self._postToOutbox(messageJson,__version__,nickname):
return 1
else:
return -1
elif postType=='newquestion':
if not fields.get('duration'):
return -1
if not fields.get('message'):
return -1
questionStr=fields['message']
qOptions=[]
for questionCtr in range(8):
if fields.get('questionOption'+str(questionCtr)):
qOptions.append(fields['questionOption'+str(questionCtr)])
if not qOptions:
return -1
messageJson= \
createQuestionPost(self.server.baseDir, \
nickname, \
self.server.domain,self.server.port, \
self.server.httpPrefix, \
fields['message'],qOptions, \
False,False,False, \
filename,attachmentMediaType, \
fields['imageDescription'], \
self.server.useBlurHash, \
fields['subject'],int(fields['duration']))
if messageJson:
if self.server.debug:
print('DEBUG: new Question')
if self._postToOutbox(messageJson,__version__,nickname):
return 1
return -1
elif postType=='newshare':
if not fields.get('itemType'):
return -1
if not fields.get('category'):
return -1
if not fields.get('location'):
return -1
if not fields.get('duration'):
return -1
if attachmentMediaType:
if attachmentMediaType!='image':
return -1
durationStr=fields['duration']
if durationStr:
if ' ' not in durationStr:
durationStr=durationStr+' days'
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'], \
durationStr,
self.server.debug)
if filename:
if os.path.isfile(filename):
os.remove(filename)
self.postToNickname=nickname
return 1
return -1
def _receiveNewPost(self,authorized: bool,postType: str,path: str) -> int:
"""A new post has been created
This creates a thread to send the new post
"""
pageNumber=1
if not authorized:
print('Not receiving new post for '+path+' because not authorized')
return None
if '/users/' not in path:
print('Not receiving new post for '+path+' because /users/ not in path')
return None
if '?'+postType+'?' not in path:
print('Not receiving new post for '+path+' because ?'+postType+'? not in path')
return None
print('New post begins: '+postType+' '+path)
if '?page=' in path:
pageNumberStr=path.split('?page=')[1]
if '?' in pageNumberStr:
pageNumberStr=pageNumberStr.split('?')[0]
if pageNumberStr.isdigit():
pageNumber=int(pageNumberStr)
path=path.split('?page=')[0]
# get the username who posted
newPostThreadName=None
if '/users/' in path:
newPostThreadName=path.split('/users/')[1]
if '/' in newPostThreadName:
newPostThreadName=newPostThreadName.split('/')[0]
if not newPostThreadName:
newPostThreadName='*'
if self.server.newPostThread.get(newPostThreadName):
print('Waiting for previous new post thread to end')
waitCtr=0
while self.server.newPostThread[newPostThreadName].isAlive() and waitCtr<8:
time.sleep(1)
waitCtr+=1
if waitCtr>=8:
print('Killing previous new post thread for '+newPostThreadName)
self.server.newPostThread[newPostThreadName].kill()
# make a copy of self.headers
headers={}
headersWithoutCookie={}
for dictEntryName,headerLine in self.headers.items():
headers[dictEntryName]=headerLine
if dictEntryName.lower()!='cookie':
headersWithoutCookie[dictEntryName]=headerLine
print('New post headers: '+str(headersWithoutCookie))
length = int(headers['Content-Length'])
if length>self.server.maxPostLength:
print('POST size too large')
return None
if not headers.get('Content-Type'):
if headers.get('Content-type'):
headers['Content-Type']=headers['Content-type']
elif headers.get('content-type'):
headers['Content-Type']=headers['content-type']
if headers.get('Content-Type'):
if ' boundary=' in headers['Content-Type']:
boundary=headers['Content-Type'].split('boundary=')[1]
if ';' in boundary:
boundary=boundary.split(';')[0]
postBytes=self.rfile.read(length)
# second length check from the bytes received
# since Content-Length could be untruthful
length=len(postBytes)
if length>self.server.maxPostLength:
print('POST size too large')
return None
# Note sending new posts needs to be synchronous, otherwise any attachments
# can get mangled if other events happen during their decoding
print('Creating new post from: '+newPostThreadName)
self._receiveNewPostProcess(authorized,postType,path,headers,length,postBytes,boundary)
return pageNumber
def do_POST(self):
POSTstartTime=time.time()
POSTtimings=[]
if not self.server.session:
print('Starting new session from POST')
self.server.session= \
createSession(self.server.useTor)
if self.server.debug:
print('DEBUG: POST to '+self.server.baseDir+ \
' path: '+self.path+' busy: '+ \
str(self.server.POSTbusy))
if self.server.POSTbusy:
currTimePOST=int(time.time())
if currTimePOST-self.server.lastPOST==0:
self.send_response(429)
self.end_headers()
return
self.server.lastPOST=currTimePOST
self.server.POSTbusy=True
if not self.headers.get('Content-type'):
print('Content-type header missing')
self.send_response(400)
self.end_headers()
self.server.POSTbusy=False
return
# remove any trailing slashes from the path
if not self.path.endswith('confirm'):
self.path= \
self.path.replace('/outbox/','/outbox').replace('/inbox/','/inbox').replace('/shares/','/shares').replace('/sharedInbox/','/sharedInbox')
if self.path=='/inbox':
if not self.server.enableSharedInbox:
self._503()
return
cookie=None
if self.headers.get('Cookie'):
cookie=self.headers['Cookie']
# check authorization
authorized = self._isAuthorized()
if self.server.debug:
if authorized:
print('POST Authorization granted')
else:
print('POST Not authorized')
print(str(self.headers))
# if this is a POST to teh outbox then check authentication
self.outboxAuthenticated=False
self.postToNickname=None
self._benchmarkPOSTtimings(POSTstartTime,POSTtimings,1)
if self.path.startswith('/login'):
# 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,register= \
htmlGetLoginCredentials(loginParams,self.server.lastLoginTime)
if loginNickname:
self.server.lastLoginTime=int(time.time())
if register:
if not registerAccount(self.server.baseDir, \
self.server.httpPrefix, \
self.server.domain, \
self.server.port, \
loginNickname,loginPassword):
self.server.POSTbusy=False
self._redirect_headers(self.server.httpPrefix+'://'+self.server.domainFull+'/login',cookie)
return
authHeader=createBasicAuthHeader(loginNickname,loginPassword)
if not authorizeBasic(self.server.baseDir,'/users/'+ \
loginNickname+'/outbox',authHeader,False):
print('Login failed: '+loginNickname)
self._clearLoginDetails(loginNickname)
self.server.POSTbusy=False
return
else:
if isSuspended(self.server.baseDir,loginNickname):
msg=htmlSuspended(self.server.baseDir).encode('utf-8')
self._login_headers('text/html',len(msg))
self._write(msg)
self.server.POSTbusy=False
return
# login success - redirect with authorization
print('Login success: '+loginNickname)
self.send_response(303)
# re-activate account if needed
activateAccount(self.server.baseDir,loginNickname,self.server.domain)
# This produces a deterministic token based on nick+password+salt
saltFilename= \
self.server.baseDir+'/accounts/'+ \
loginNickname+'@'+self.server.domain+'/.salt'
salt=createPassword(32)
if os.path.isfile(saltFilename):
try:
with open(saltFilename, 'r') as fp:
salt = fp.read()
except Exception as e:
print('WARN: Unable to read salt for '+ \
loginNickname+' '+str(e))
else:
try:
with open(saltFilename, 'w') as fp:
fp.write(salt)
except Exception as e:
print('WARN: Unable to save salt for '+ \
loginNickname+' '+str(e))
token=sha256((loginNickname+loginPassword+salt).encode('utf-8')).hexdigest()
self.server.tokens[loginNickname]=token
loginHandle=loginNickname+'@'+self.server.domain
tokenFilename= \
self.server.baseDir+'/accounts/'+ \
loginHandle+'/.token'
try:
with open(tokenFilename, 'w') as fp:
fp.write(token)
except Exception as e:
print('WARN: Unable to save token for '+loginNickname+' '+str(e))
personUpgradeActor(self.server.baseDir,None,loginHandle, \
self.server.baseDir+'/accounts/'+loginHandle+'.json')
self.server.tokensLookup[self.server.tokens[loginNickname]]=loginNickname
self.send_header('Set-Cookie', \
'epicyon='+self.server.tokens[loginNickname]+'; SameSite=Strict')
self.send_header('Location', \
self.server.httpPrefix+'://'+ \
self.server.domainFull+ \
'/users/'+loginNickname+'/'+self.server.defaultTimeline)
self.send_header('Content-Length', '0')
self.send_header('X-Robots-Tag','noindex')
self.end_headers()
self.server.POSTbusy=False
return
self.send_response(200)
self.end_headers()
self.server.POSTbusy=False
return
self._benchmarkPOSTtimings(POSTstartTime,POSTtimings,2)
# update of profile/avatar from web interface
if authorized and self.path.endswith('/profiledata'):
actorStr= \
self.server.httpPrefix+'://'+self.server.domainFull+ \
self.path.replace('/profiledata','').replace('/editprofile','')
if ' boundary=' in self.headers['Content-type']:
boundary=self.headers['Content-type'].split('boundary=')[1]
if ';' in boundary:
boundary=boundary.split(';')[0]
nickname=getNicknameFromActor(actorStr)
if not nickname:
print('WARN: nickname not found in '+actorStr)
self._redirect_headers(actorStr,cookie)
self.server.POSTbusy=False
return
length = int(self.headers['Content-length'])
if length>self.server.maxPostLength:
print('Maximum profile data length exceeded '+str(length))
self._redirect_headers(actorStr,cookie)
self.server.POSTbusy=False
return
# read the bytes of the http form POST
postBytes=self.rfile.read(length)
# extract each image type
actorChanged=True
profileMediaTypes=['avatar','image','banner','instanceLogo']
profileMediaTypesUploaded={}
for mType in profileMediaTypes:
if self.server.debug:
print('DEBUG: profile update extracting '+mType+' image from POST')
mediaBytes,postBytes=extractMediaInFormPOST(postBytes,boundary,mType)
if mediaBytes:
if self.server.debug:
print('DEBUG: profile update '+mType+' image was found. '+str(len(mediaBytes))+' bytes')
else:
if self.server.debug:
print('DEBUG: profile update, no '+mType+' image was found in POST')
continue
# Note: a .temp extension is used here so that at no time is
# an image with metadata publicly exposed, even for a few mS
if mType!='instanceLogo':
filenameBase= \
self.server.baseDir+'/accounts/'+ \
nickname+'@'+self.server.domain+'/'+mType+'.temp'
else:
filenameBase= \
self.server.baseDir+'/accounts/login.temp'
filename,attachmentMediaType= \
saveMediaInFormPOST(mediaBytes,self.server.debug,filenameBase)
if filename:
if self.server.debug:
print('DEBUG: profile update POST '+mType+' media filename is '+filename)
else:
if self.server.debug:
print('DEBUG: profile update, no '+mType+' media filename in POST')
continue
if self.server.debug:
print('DEBUG: POST '+mType+' media removing metadata')
postImageFilename=filename.replace('.temp','')
removeMetaData(filename,postImageFilename)
if os.path.isfile(postImageFilename):
print('profile update POST '+mType+' image saved to '+postImageFilename)
if mType!='instanceLogo':
lastPartOfImageFilename=postImageFilename.split('/')[-1]
profileMediaTypesUploaded[mType]=lastPartOfImageFilename
actorChanged=True
else:
print('ERROR: profile update POST '+mType+' image could not be saved to '+postImageFilename)
fields=extractTextFieldsInPOST(postBytes,boundary,self.server.debug)
if self.server.debug:
if fields:
print('DEBUG: profile update text field extracted from POST '+str(fields))
else:
print('WARN: profile update, no text fields could be extracted from POST')
actorFilename= \
self.server.baseDir+'/accounts/'+ \
nickname+'@'+self.server.domain+'.json'
if os.path.isfile(actorFilename):
actorJson=loadJson(actorFilename)
if actorJson:
# update the avatar/image url file extension
for mType,lastPartOfImageFilename in profileMediaTypesUploaded.items():
if mType=='avatar':
lastPartOfUrl=actorJson['icon']['url'].split('/')[-1]
actorJson['icon']['url']= \
actorJson['icon']['url'].replace('/'+lastPartOfUrl, \
'/'+lastPartOfImageFilename)
elif mType=='image':
lastPartOfUrl=actorJson['image']['url'].split('/')[-1]
actorJson['image']['url']= \
actorJson['image']['url'].replace('/'+lastPartOfUrl, \
'/'+lastPartOfImageFilename)
skillCtr=1
newSkills={}
while skillCtr<10:
skillName=fields.get('skillName'+str(skillCtr))
if not skillName:
skillCtr+=1
continue
skillValue=fields.get('skillValue'+str(skillCtr))
if not skillValue:
skillCtr+=1
continue
if not actorJson['skills'].get(skillName):
actorChanged=True
else:
if actorJson['skills'][skillName]!=int(skillValue):
actorChanged=True
newSkills[skillName]=int(skillValue)
skillCtr+=1
if len(actorJson['skills'].items())!=len(newSkills.items()):
actorChanged=True
actorJson['skills']=newSkills
if fields.get('password'):
if fields.get('passwordconfirm'):
if actorJson['password']==fields['passwordconfirm']:
if len(actorJson['password'])>2:
# set password
storeBasicCredentials(self.server.baseDir,nickname,actorJson['password'])
if fields.get('displayNickname'):
if fields['displayNickname']!=actorJson['name']:
actorJson['name']=fields['displayNickname']
actorChanged=True
if fields.get('themeDropdown'):
setTheme(self.server.baseDir,fields['themeDropdown'])
#self.server.iconsCache={}
currentEmailAddress=getEmailAddress(actorJson)
if fields.get('email'):
if fields['email']!=currentEmailAddress:
setEmailAddress(actorJson,fields['email'])
actorChanged=True
else:
if currentEmailAddress:
setEmailAddress(actorJson,'')
actorChanged=True
currentXmppAddress=getXmppAddress(actorJson)
if fields.get('xmppAddress'):
if fields['xmppAddress']!=currentXmppAddress:
setXmppAddress(actorJson,fields['xmppAddress'])
actorChanged=True
else:
if currentXmppAddress:
setXmppAddress(actorJson,'')
actorChanged=True
currentMatrixAddress=getMatrixAddress(actorJson)
if fields.get('matrixAddress'):
if fields['matrixAddress']!=currentMatrixAddress:
setMatrixAddress(actorJson,fields['matrixAddress'])
actorChanged=True
else:
if currentMatrixAddress:
setMatrixAddress(actorJson,'')
actorChanged=True
currentPGPpubKey=getPGPpubKey(actorJson)
if fields.get('pgp'):
if fields['pgp']!=currentPGPpubKey:
setPGPpubKey(actorJson,fields['pgp'])
actorChanged=True
else:
if currentPGPpubKey:
setPGPpubKey(actorJson,'')
actorChanged=True
currentDonateUrl=getDonationUrl(actorJson)
if fields.get('donateUrl'):
if fields['donateUrl']!=currentDonateUrl:
setDonationUrl(actorJson,fields['donateUrl'])
actorChanged=True
else:
if currentDonateUrl:
setDonationUrl(actorJson,'')
actorChanged=True
if fields.get('instanceTitle'):
currInstanceTitle=getConfigParam(self.server.baseDir,'instanceTitle')
if fields['instanceTitle']!=currInstanceTitle:
setConfigParam(self.server.baseDir,'instanceTitle',fields['instanceTitle'])
currInstanceDescriptionShort=getConfigParam(self.server.baseDir,'instanceDescriptionShort')
if fields.get('instanceDescriptionShort'):
if fields['instanceDescriptionShort']!=currInstanceDescriptionShort:
setConfigParam(self.server.baseDir,'instanceDescriptionShort',fields['instanceDescriptionShort'])
else:
if currInstanceDescriptionShort:
setConfigParam(self.server.baseDir,'instanceDescriptionShort','')
currInstanceDescription=getConfigParam(self.server.baseDir,'instanceDescription')
if fields.get('instanceDescription'):
if fields['instanceDescription']!=currInstanceDescription:
setConfigParam(self.server.baseDir,'instanceDescription',fields['instanceDescription'])
else:
if currInstanceDescription:
setConfigParam(self.server.baseDir,'instanceDescription','')
if fields.get('bio'):
if fields['bio']!=actorJson['summary']:
actorTags={}
actorJson['summary']= \
addHtmlTags(self.server.baseDir, \
self.server.httpPrefix, \
nickname, \
self.server.domainFull, \
fields['bio'],[],actorTags)
if actorTags:
actorJson['tag']=[]
for tagName,tag in actorTags.items():
actorJson['tag'].append(tag)
actorChanged=True
else:
if actorJson['summary']:
actorJson['summary']=''
actorChanged=True
if fields.get('moderators'):
adminNickname=getConfigParam(self.server.baseDir,'admin')
if self.path.startswith('/users/'+adminNickname+'/'):
moderatorsFile=self.server.baseDir+'/accounts/moderators.txt'
clearModeratorStatus(self.server.baseDir)
if ',' in fields['moderators']:
# if the list was given as comma separated
modFile=open(moderatorsFile,"w+")
for modNick in fields['moderators'].split(','):
modNick=modNick.strip()
if os.path.isdir(self.server.baseDir+ \
'/accounts/'+modNick+ \
'@'+self.server.domain):
modFile.write(modNick+'\n')
modFile.close()
for modNick in fields['moderators'].split(','):
modNick=modNick.strip()
if os.path.isdir(self.server.baseDir+ \
'/accounts/'+modNick+ \
'@'+self.server.domain):
setRole(self.server.baseDir, \
modNick,self.server.domain, \
'instance','moderator')
else:
# nicknames on separate lines
modFile=open(moderatorsFile,"w+")
for modNick in fields['moderators'].split('\n'):
modNick=modNick.strip()
if os.path.isdir(self.server.baseDir+ \
'/accounts/'+modNick+ \
'@'+self.server.domain):
modFile.write(modNick+'\n')
modFile.close()
for modNick in fields['moderators'].split('\n'):
modNick=modNick.strip()
if os.path.isdir(self.server.baseDir+ \
'/accounts/'+modNick+ \
'@'+self.server.domain):
setRole(self.server.baseDir, \
modNick,self.server.domain, \
'instance','moderator')
if fields.get('removeScheduledPosts'):
if fields['removeScheduledPosts']=='on':
removeScheduledPosts(self.server.baseDir,nickname,self.server.domain)
approveFollowers=False
if fields.get('approveFollowers'):
if fields['approveFollowers']=='on':
approveFollowers=True
if approveFollowers!=actorJson['manuallyApprovesFollowers']:
actorJson['manuallyApprovesFollowers']=approveFollowers
actorChanged=True
if fields.get('mediaInstance'):
self.server.mediaInstance=False
self.server.defaultTimeline='inbox'
if fields['mediaInstance']=='on':
self.server.mediaInstance=True
self.server.defaultTimeline='tlmedia'
setConfigParam(self.server.baseDir,"mediaInstance", \
self.server.mediaInstance)
else:
if self.server.mediaInstance:
self.server.mediaInstance=False
self.server.defaultTimeline='inbox'
setConfigParam(self.server.baseDir,"mediaInstance", \
self.server.mediaInstance)
# only receive DMs from accounts you follow
followDMsFilename= \
self.server.baseDir+'/accounts/'+ \
nickname+'@'+self.server.domain+'/.followDMs'
followDMsActive=False
if fields.get('followDMs'):
if fields['followDMs']=='on':
followDMsActive=True
with open(followDMsFilename, "w") as followDMsFile:
followDMsFile.write('\n')
if not followDMsActive:
if os.path.isfile(followDMsFilename):
os.remove(followDMsFilename)
# remove Twitter retweets
removeTwitterFilename= \
self.server.baseDir+'/accounts/'+ \
nickname+'@'+self.server.domain+'/.removeTwitter'
removeTwitterActive=False
if fields.get('removeTwitter'):
if fields['removeTwitter']=='on':
removeTwitterActive=True
with open(removeTwitterFilename, "w") as removeTwitterFile:
removeTwitterFile.write('\n')
if not removeTwitterActive:
if os.path.isfile(removeTwitterFilename):
os.remove(removeTwitterFilename)
# this account is a bot
if fields.get('isBot'):
if fields['isBot']=='on':
if actorJson['type']!='Service':
actorJson['type']='Service'
actorChanged=True
else:
# this account is a group
if fields.get('isGroup'):
if fields['isGroup']=='on':
if actorJson['type']!='Group':
actorJson['type']='Group'
actorChanged=True
else:
# this account is a person (default)
if actorJson['type']!='Person':
actorJson['type']='Person'
actorChanged=True
# save filtered words list
filterFilename= \
self.server.baseDir+'/accounts/'+ \
nickname+'@'+self.server.domain+'/filters.txt'
if fields.get('filteredWords'):
with open(filterFilename, "w") as filterfile:
filterfile.write(fields['filteredWords'])
else:
if os.path.isfile(filterFilename):
os.remove(filterFilename)
# word replacements
switchFilename= \
self.server.baseDir+'/accounts/'+ \
nickname+'@'+self.server.domain+'/replacewords.txt'
if fields.get('switchWords'):
with open(switchFilename, "w") as switchfile:
switchfile.write(fields['switchWords'])
else:
if os.path.isfile(switchFilename):
os.remove(switchFilename)
# save blocked accounts list
blockedFilename= \
self.server.baseDir+'/accounts/'+ \
nickname+'@'+self.server.domain+'/blocking.txt'
if fields.get('blocked'):
with open(blockedFilename, "w") as blockedfile:
blockedfile.write(fields['blocked'])
else:
if os.path.isfile(blockedFilename):
os.remove(blockedFilename)
# save allowed instances list
allowedInstancesFilename= \
self.server.baseDir+'/accounts/'+ \
nickname+'@'+self.server.domain+'/allowedinstances.txt'
if fields.get('allowedInstances'):
with open(allowedInstancesFilename, "w") as allowedInstancesFile:
allowedInstancesFile.write(fields['allowedInstances'])
else:
if os.path.isfile(allowedInstancesFilename):
os.remove(allowedInstancesFilename)
# save actor json file within accounts
if actorChanged:
randomizeActorImages(actorJson)
saveJson(actorJson,actorFilename)
# also copy to the actors cache and personCache in memory
storePersonInCache(self.server.baseDir, \
actorJson['id'],actorJson, \
self.server.personCache)
# clear any cached images for this actor
removeAvatarFromCache(self.server.baseDir,actorJson['id'].replace('/','-'))
# save the actor to the cache
actorCacheFilename= \
self.server.baseDir+'/cache/actors/'+ \
actorJson['id'].replace('/','#')+'.json'
saveJson(actorJson,actorCacheFilename)
# send profile update to followers
updateActorJson={
'type': 'Update',
'actor': actorJson['id'],
'to': [actorJson['id']+'/followers'],
'cc': ['https://www.w3.org/ns/activitystreams#Public'],
'object': actorJson
}
self._postToOutbox(updateActorJson,__version__,nickname)
if fields.get('deactivateThisAccount'):
if fields['deactivateThisAccount']=='on':
deactivateAccount(self.server.baseDir,nickname,self.server.domain)
self._clearLoginDetails(nickname)
self.server.POSTbusy=False
return
self._redirect_headers(actorStr,cookie)
self.server.POSTbusy=False
return
self._benchmarkPOSTtimings(POSTstartTime,POSTtimings,3)
# moderator action buttons
if authorized and '/users/' in self.path and \
self.path.endswith('/moderationaction'):
actorStr= \
self.server.httpPrefix+'://'+self.server.domainFull+ \
self.path.replace('/moderationaction','')
length = int(self.headers['Content-length'])
moderationParams=self.rfile.read(length).decode('utf-8')
print('moderationParams: '+moderationParams)
if '&' in moderationParams:
moderationText=None
moderationButton=None
for moderationStr in moderationParams.split('&'):
print('moderationStr: '+moderationStr)
if moderationStr.startswith('moderationAction'):
if '=' in moderationStr:
moderationText= \
moderationStr.split('=')[1].strip()
moderationText= \
moderationText.replace('+',' ').replace('%40','@').replace('%3A',':').replace('%23','#').strip()
elif moderationStr.startswith('submitInfo'):
msg=htmlModerationInfo(self.server.translate, \
self.server.baseDir, \
self.server.httpPrefix).encode('utf-8')
self._login_headers('text/html',len(msg))
self._write(msg)
self.server.POSTbusy=False
return
elif moderationStr.startswith('submitBlock'):
moderationButton='block'
elif moderationStr.startswith('submitUnblock'):
moderationButton='unblock'
elif moderationStr.startswith('submitSuspend'):
moderationButton='suspend'
elif moderationStr.startswith('submitUnsuspend'):
moderationButton='unsuspend'
elif moderationStr.startswith('submitRemove'):
moderationButton='remove'
if moderationButton and moderationText:
if self.server.debug:
print('moderationButton: '+moderationButton)
print('moderationText: '+moderationText)
nickname=moderationText
if nickname.startswith('http') or \
nickname.startswith('dat'):
nickname=getNicknameFromActor(nickname)
if '@' in nickname:
nickname=nickname.split('@')[0]
if moderationButton=='suspend':
suspendAccount(self.server.baseDir,nickname, \
self.server.domain)
if moderationButton=='unsuspend':
unsuspendAccount(self.server.baseDir,nickname)
if moderationButton=='block':
fullBlockDomain=None
if moderationText.startswith('http') or \
moderationText.startswith('dat'):
blockDomain,blockPort= \
getDomainFromActor(moderationText)
fullBlockDomain=blockDomain
if blockPort:
if blockPort!=80 and blockPort!=443:
if ':' not in blockDomain:
fullBlockDomain= \
blockDomain+':'+str(blockPort)
if '@' in moderationText:
fullBlockDomain=moderationText.split('@')[1]
if fullBlockDomain or nickname.startswith('#'):
addGlobalBlock(self.server.baseDir, \
nickname,fullBlockDomain)
if moderationButton=='unblock':
fullBlockDomain=None
if moderationText.startswith('http') or \
moderationText.startswith('dat'):
blockDomain,blockPort= \
getDomainFromActor(moderationText)
fullBlockDomain=blockDomain
if blockPort:
if blockPort!=80 and blockPort!=443:
if ':' not in blockDomain:
fullBlockDomain= \
blockDomain+':'+str(blockPort)
if '@' in moderationText:
fullBlockDomain=moderationText.split('@')[1]
if fullBlockDomain or nickname.startswith('#'):
removeGlobalBlock(self.server.baseDir, \
nickname,fullBlockDomain)
if moderationButton=='remove':
if '/statuses/' not in moderationText:
removeAccount(self.server.baseDir, \
nickname, \
self.server.domain, \
self.server.port)
else:
# remove a post or thread
postFilename= \
locatePost(self.server.baseDir, \
nickname,self.server.domain, \
moderationText)
if postFilename:
if canRemovePost(self.server.baseDir, \
nickname, \
self.server.domain, \
self.server.port, \
moderationText):
deletePost(self.server.baseDir, \
self.server.httpPrefix, \
nickname,self.server.domain, \
postFilename, \
self.server.debug)
self._redirect_headers(actorStr+'/moderation',cookie)
self.server.POSTbusy=False
return
self._benchmarkPOSTtimings(POSTstartTime,POSTtimings,4)
searchForEmoji=False
if self.path.endswith('/searchhandleemoji'):
searchForEmoji=True
self.path=self.path.replace('/searchhandleemoji','/searchhandle')
if self.server.debug:
print('DEBUG: searching for emoji')
print('authorized: '+str(authorized))
self._benchmarkPOSTtimings(POSTstartTime,POSTtimings,5)
# a vote/question/poll is posted
if authorized and \
(self.path.endswith('/question') or '/question?page=' in self.path):
pageNumber=1
if '?page=' in self.path:
pageNumberStr=self.path.split('?page=')[1]
if pageNumberStr.isdigit():
pageNumber=int(pageNumberStr)
self.path=self.path.split('?page=')[0]
# the actor who votes
actor= \
self.server.httpPrefix+'://'+ \
self.server.domainFull+self.path.replace('/question','')
nickname=getNicknameFromActor(actor)
if not nickname:
self._redirect_headers(actor+'/'+self.server.defaultTimeline+'?page='+ \
str(pageNumber),cookie)
self.server.POSTbusy=False
return
# get the parameters
length = int(self.headers['Content-length'])
questionParams=self.rfile.read(length).decode('utf-8')
questionParams= \
questionParams.replace('+',' ').replace('%40','@').replace('%3A',':').replace('%23','#').replace('%2F','/').replace('%3F','').strip()
# post being voted on
messageId=None
if 'messageId=' in questionParams:
messageId=questionParams.split('messageId=')[1]
if '&' in messageId:
messageId=messageId.split('&')[0]
answer=None
if 'answer=' in questionParams:
answer=questionParams.split('answer=')[1]
if '&' in answer:
answer=answer.split('&')[0]
self._sendReplyToQuestion(nickname,messageId,answer)
self._redirect_headers(actor+'/'+self.server.defaultTimeline+ \
'?page='+str(pageNumber),cookie)
self.server.POSTbusy=False
return
self._benchmarkPOSTtimings(POSTstartTime,POSTtimings,6)
# a search was made
if (authorized or searchForEmoji) and \
(self.path.endswith('/searchhandle') or \
'/searchhandle?page=' in self.path):
# get the page number
pageNumber=1
if '/searchhandle?page=' in self.path:
pageNumberStr=self.path.split('/searchhandle?page=')[1]
if pageNumberStr.isdigit():
pageNumber=int(pageNumberStr)
self.path=self.path.split('?page=')[0]
actorStr= \
self.server.httpPrefix+'://'+ \
self.server.domainFull+ \
self.path.replace('/searchhandle','')
length = int(self.headers['Content-length'])
searchParams=self.rfile.read(length).decode('utf-8')
if 'submitBack=' in searchParams:
# go back on search screen
self._redirect_headers(actorStr+'/'+self.server.defaultTimeline,cookie)
self.server.POSTbusy=False
return
if 'searchtext=' in searchParams:
searchStr=searchParams.split('searchtext=')[1]
if '&' in searchStr:
searchStr=searchStr.split('&')[0]
searchStr= \
searchStr.replace('+',' ').replace('%20',' ').replace('%40','@').replace('%3A',':').replace('%2F','/').replace('%23','#')
searchStr=searchStr.strip()
if self.server.debug:
print('searchStr: '+searchStr)
if searchForEmoji:
searchStr=':'+searchStr+':'
if searchStr.startswith('#'):
nickname=getNicknameFromActor(actorStr)
# hashtag search
hashtagStr= \
htmlHashtagSearch(nickname, \
self.server.domain,self.server.port, \
self.server.recentPostsCache, \
self.server.maxRecentPosts, \
self.server.translate, \
self.server.baseDir,searchStr[1:],1, \
maxPostsInFeed,self.server.session, \
self.server.cachedWebfingers, \
self.server.personCache, \
self.server.httpPrefix, \
self.server.projectVersion)
if hashtagStr:
msg=hashtagStr.encode('utf-8')
self._login_headers('text/html',len(msg))
self._write(msg)
self.server.POSTbusy=False
return
elif searchStr.startswith('*'):
# skill search
searchStr=searchStr.replace('*','').strip()
skillStr= \
htmlSkillsSearch(self.server.translate, \
self.server.baseDir, \
self.server.httpPrefix, \
searchStr, \
self.server.instanceOnlySkillsSearch, \
64)
if skillStr:
msg=skillStr.encode('utf-8')
self._login_headers('text/html',len(msg))
self._write(msg)
self.server.POSTbusy=False
return
elif '@' in searchStr:
# profile search
nickname=getNicknameFromActor(actorStr)
if not self.server.session:
self.server.session= \
createSession(self.server.useTor)
profileStr= \
htmlProfileAfterSearch(self.server.recentPostsCache, \
self.server.maxRecentPosts, \
self.server.translate, \
self.server.baseDir, \
self.path.replace('/searchhandle',''), \
self.server.httpPrefix, \
nickname, \
self.server.domain,self.server.port, \
searchStr, \
self.server.session, \
self.server.cachedWebfingers, \
self.server.personCache, \
self.server.debug, \
self.server.projectVersion)
if profileStr:
msg=profileStr.encode('utf-8')
self._login_headers('text/html',len(msg))
self._write(msg)
self.server.POSTbusy=False
return
else:
self._redirect_headers(actorStr+'/search',cookie)
self.server.POSTbusy=False
return
elif searchStr.startswith(':') or \
searchStr.lower().strip('\n').endswith(' emoji'):
# eg. "cat emoji"
if searchStr.lower().strip('\n').endswith(' emoji'):
searchStr= \
searchStr.lower().strip('\n').replace(' emoji','')
# emoji search
emojiStr= \
htmlSearchEmoji(self.server.translate, \
self.server.baseDir, \
self.server.httpPrefix, \
searchStr)
if emojiStr:
msg=emojiStr.encode('utf-8')
self._login_headers('text/html',len(msg))
self._write(msg)
self.server.POSTbusy=False
return
else:
# shared items search
sharedItemsStr= \
htmlSearchSharedItems(self.server.translate, \
self.server.baseDir, \
searchStr,pageNumber, \
maxPostsInFeed, \
self.server.httpPrefix, \
self.server.domainFull, \
actorStr)
if sharedItemsStr:
msg=sharedItemsStr.encode('utf-8')
self._login_headers('text/html',len(msg))
self._write(msg)
self.server.POSTbusy=False
return
self._redirect_headers(actorStr+'/'+self.server.defaultTimeline,cookie)
self.server.POSTbusy=False
return
self._benchmarkPOSTtimings(POSTstartTime,POSTtimings,7)
# removes a shared item
if authorized and self.path.endswith('/rmshare'):
originPathStr= \
self.server.httpPrefix+'://'+self.server.domainFull+ \
self.path.split('/rmshare')[0]
length = int(self.headers['Content-length'])
removeShareConfirmParams=self.rfile.read(length).decode('utf-8')
if '&submitYes=' in removeShareConfirmParams:
removeShareConfirmParams= \
removeShareConfirmParams.replace('%20',' ').replace('%40','@').replace('%3A',':').replace('%2F','/').replace('%23','#').replace('+',' ').strip()
shareActor=removeShareConfirmParams.split('actor=')[1]
if '&' in shareActor:
shareActor=shareActor.split('&')[0]
shareName=removeShareConfirmParams.split('shareName=')[1]
if '&' in shareName:
shareName=shareName.split('&')[0]
shareNickname=getNicknameFromActor(shareActor)
if shareNickname:
shareDomain,sharePort=getDomainFromActor(shareActor)
removeShare(self.server.baseDir, \
shareNickname,shareDomain,shareName)
self._redirect_headers(originPathStr+'/tlshares',cookie)
self.server.POSTbusy=False
return
self._benchmarkPOSTtimings(POSTstartTime,POSTtimings,8)
# removes a post
if authorized and self.path.endswith('/rmpost'):
pageNumber=1
originPathStr= \
self.server.httpPrefix+'://'+self.server.domainFull+ \
self.path.split('/rmpost')[0]
length = int(self.headers['Content-length'])
removePostConfirmParams=self.rfile.read(length).decode('utf-8')
if '&submitYes=' in removePostConfirmParams:
removePostConfirmParams= \
removePostConfirmParams.replace('%20',' ').replace('%40','@').replace('%3A',':').replace('%2F','/').replace('%23','#').strip()
removeMessageId= \
removePostConfirmParams.split('messageId=')[1]
if '&' in removeMessageId:
removeMessageId=removeMessageId.split('&')[0]
if 'pageNumber=' in removePostConfirmParams:
pageNumberStr=removePostConfirmParams.split('pageNumber=')[1]
if '&' in pageNumberStr:
pageNumberStr=pageNumberStr.split('&')[0]
if pageNumberStr.isdigit():
pageNumber=int(pageNumberStr)
yearStr=None
if 'year=' in removePostConfirmParams:
yearStr=removePostConfirmParams.split('year=')[1]
if '&' in yearStr:
yearStr=yearStr.split('&')[0]
monthStr=None
if 'month=' in removePostConfirmParams:
monthStr=removePostConfirmParams.split('month=')[1]
if '&' in monthStr:
monthStr=monthStr.split('&')[0]
if '/statuses/' in removeMessageId:
removePostActor=removeMessageId.split('/statuses/')[0]
if originPathStr in removePostActor:
deleteJson= {
"@context": "https://www.w3.org/ns/activitystreams",
'actor': removePostActor,
'object': removeMessageId,
'to': ['https://www.w3.org/ns/activitystreams#Public',removePostActor],
'cc': [removePostActor+'/followers'],
'type': 'Delete'
}
self.postToNickname=getNicknameFromActor(removePostActor)
if self.postToNickname:
if monthStr and yearStr:
if monthStr.isdigit() and yearStr.isdigit():
removeCalendarEvent(self.server.baseDir, \
self.postToNickname, \
self.server.domain, \
int(yearStr),int(monthStr), \
removeMessageId)
self._postToOutboxThread(deleteJson)
if pageNumber==1:
self._redirect_headers(originPathStr+'/outbox',cookie)
else:
self._redirect_headers(originPathStr+'/outbox?page='+ \
str(pageNumber),cookie)
self.server.POSTbusy=False
return
self._benchmarkPOSTtimings(POSTstartTime,POSTtimings,9)
# decision to follow in the web interface is confirmed
if authorized and self.path.endswith('/followconfirm'):
originPathStr= \
self.server.httpPrefix+'://'+self.server.domainFull+ \
self.path.split('/followconfirm')[0]
followerNickname=getNicknameFromActor(originPathStr)
length = int(self.headers['Content-length'])
followConfirmParams=self.rfile.read(length).decode('utf-8')
if '&submitView=' in followConfirmParams:
followingActor= \
followConfirmParams.replace('%3A',':').replace('%2F','/').split('actor=')[1]
if '&' in followingActor:
followingActor=followingActor.split('&')[0]
self._redirect_headers(followingActor,cookie)
self.server.POSTbusy=False
return
if '&submitYes=' in followConfirmParams:
followingActor= \
followConfirmParams.replace('%3A',':').replace('%2F','/').split('actor=')[1]
if '&' in followingActor:
followingActor=followingActor.split('&')[0]
followingNickname=getNicknameFromActor(followingActor)
followingDomain,followingPort=getDomainFromActor(followingActor)
if followerNickname==followingNickname and \
followingDomain==self.server.domain and \
followingPort==self.server.port:
if self.server.debug:
print('You cannot follow yourself!')
else:
if self.server.debug:
print('Sending follow request from '+ \
followerNickname+' to '+followingActor)
sendFollowRequest(self.server.session, \
self.server.baseDir, \
followerNickname, \
self.server.domain,self.server.port, \
self.server.httpPrefix, \
followingNickname, \
followingDomain, \
followingPort,self.server.httpPrefix, \
False,self.server.federationList, \
self.server.sendThreads, \
self.server.postLog, \
self.server.cachedWebfingers, \
self.server.personCache, \
self.server.debug, \
self.server.projectVersion)
self._redirect_headers(originPathStr,cookie)
self.server.POSTbusy=False
return
self._benchmarkPOSTtimings(POSTstartTime,POSTtimings,10)
# decision to unfollow in the web interface is confirmed
if authorized and self.path.endswith('/unfollowconfirm'):
originPathStr= \
self.server.httpPrefix+'://'+self.server.domainFull+ \
self.path.split('/unfollowconfirm')[0]
followerNickname=getNicknameFromActor(originPathStr)
length = int(self.headers['Content-length'])
followConfirmParams=self.rfile.read(length).decode('utf-8')
if '&submitYes=' in followConfirmParams:
followingActor= \
followConfirmParams.replace('%3A',':').replace('%2F','/').split('actor=')[1]
if '&' in followingActor:
followingActor=followingActor.split('&')[0]
followingNickname=getNicknameFromActor(followingActor)
followingDomain,followingPort=getDomainFromActor(followingActor)
if followerNickname==followingNickname and \
followingDomain==self.server.domain and \
followingPort==self.server.port:
if self.server.debug:
print('You cannot unfollow yourself!')
else:
if self.server.debug:
print(followerNickname+' stops following '+followingActor)
followActor= \
self.server.httpPrefix+'://'+ \
self.server.domainFull+ \
'/users/'+followerNickname
statusNumber,published = getStatusNumber()
followId=followActor+'/statuses/'+str(statusNumber)
unfollowJson = {
'@context': 'https://www.w3.org/ns/activitystreams',
'id': followId+'/undo',
'type': 'Undo',
'actor': followActor,
'object': {
'id': followId,
'type': 'Follow',
'actor': followActor,
'object': followingActor
}
}
pathUsersSection=self.path.split('/users/')[1]
self.postToNickname=pathUsersSection.split('/')[0]
self._postToOutboxThread(unfollowJson)
self._redirect_headers(originPathStr,cookie)
self.server.POSTbusy=False
return
self._benchmarkPOSTtimings(POSTstartTime,POSTtimings,11)
# decision to unblock in the web interface is confirmed
if authorized and self.path.endswith('/unblockconfirm'):
originPathStr= \
self.server.httpPrefix+'://'+self.server.domainFull+ \
self.path.split('/unblockconfirm')[0]
blockerNickname=getNicknameFromActor(originPathStr)
if not blockerNickname:
print('WARN: unable to find nickname in '+originPathStr)
self._redirect_headers(originPathStr,cookie)
self.server.POSTbusy=False
return
length = int(self.headers['Content-length'])
blockConfirmParams=self.rfile.read(length).decode('utf-8')
if '&submitYes=' in blockConfirmParams:
blockingActor= \
blockConfirmParams.replace('%3A',':').replace('%2F','/').split('actor=')[1]
if '&' in blockingActor:
blockingActor=blockingActor.split('&')[0]
blockingNickname=getNicknameFromActor(blockingActor)
if not blockingNickname:
print('WARN: unable to find nickname in '+blockingActor)
self._redirect_headers(originPathStr,cookie)
self.server.POSTbusy=False
return
blockingDomain,blockingPort=getDomainFromActor(blockingActor)
blockingDomainFull=blockingDomain
if blockingPort:
if blockingPort!=80 and blockingPort!=443:
if ':' not in blockingDomain:
blockingDomainFull= \
blockingDomain+':'+str(blockingPort)
if blockerNickname==blockingNickname and \
blockingDomain==self.server.domain and \
blockingPort==self.server.port:
if self.server.debug:
print('You cannot unblock yourself!')
else:
if self.server.debug:
print(blockerNickname+' stops blocking '+blockingActor)
removeBlock(self.server.baseDir,blockerNickname,self.server.domain, \
blockingNickname,blockingDomainFull)
self._redirect_headers(originPathStr,cookie)
self.server.POSTbusy=False
return
self._benchmarkPOSTtimings(POSTstartTime,POSTtimings,12)
# decision to block in the web interface is confirmed
if authorized and self.path.endswith('/blockconfirm'):
originPathStr= \
self.server.httpPrefix+'://'+self.server.domainFull+ \
self.path.split('/blockconfirm')[0]
blockerNickname=getNicknameFromActor(originPathStr)
if not blockerNickname:
print('WARN: unable to find nickname in '+originPathStr)
self._redirect_headers(originPathStr,cookie)
self.server.POSTbusy=False
return
length = int(self.headers['Content-length'])
blockConfirmParams=self.rfile.read(length).decode('utf-8')
if '&submitYes=' in blockConfirmParams:
blockingActor= \
blockConfirmParams.replace('%3A',':').replace('%2F','/').split('actor=')[1]
if '&' in blockingActor:
blockingActor=blockingActor.split('&')[0]
blockingNickname=getNicknameFromActor(blockingActor)
if not blockingNickname:
print('WARN: unable to find nickname in '+blockingActor)
self._redirect_headers(originPathStr,cookie)
self.server.POSTbusy=False
return
blockingDomain,blockingPort= \
getDomainFromActor(blockingActor)
blockingDomainFull=blockingDomain
if blockingPort:
if blockingPort!=80 and blockingPort!=443:
if ':' not in blockingDomain:
blockingDomainFull= \
blockingDomain+':'+str(blockingPort)
if blockerNickname==blockingNickname and \
blockingDomain==self.server.domain and \
blockingPort==self.server.port:
if self.server.debug:
print('You cannot block yourself!')
else:
if self.server.debug:
print('Adding block by '+blockerNickname+ \
' of '+blockingActor)
addBlock(self.server.baseDir,blockerNickname, \
self.server.domain, \
blockingNickname,blockingDomainFull)
self._redirect_headers(originPathStr,cookie)
self.server.POSTbusy=False
return
self._benchmarkPOSTtimings(POSTstartTime,POSTtimings,13)
# an option was chosen from person options screen
# view/follow/block/report
if authorized and self.path.endswith('/personoptions'):
pageNumber=1
originPathStr= \
self.server.httpPrefix+'://'+self.server.domainFull+ \
self.path.split('/personoptions')[0]
chooserNickname=getNicknameFromActor(originPathStr)
if not chooserNickname:
print('WARN: unable to find nickname in '+originPathStr)
self._redirect_headers(originPathStr,cookie)
self.server.POSTbusy=False
return
length = int(self.headers['Content-length'])
optionsConfirmParams= \
self.rfile.read(length).decode('utf-8').replace('%3A',':').replace('%2F','/')
# page number to return to
if 'pageNumber=' in optionsConfirmParams:
pageNumberStr=optionsConfirmParams.split('pageNumber=')[1]
if '&' in pageNumberStr:
pageNumberStr=pageNumberStr.split('&')[0]
if pageNumberStr.isdigit():
pageNumber=int(pageNumberStr)
# actor for the person
optionsActor=optionsConfirmParams.split('actor=')[1]
if '&' in optionsActor:
optionsActor=optionsActor.split('&')[0]
# url of the avatar
optionsAvatarUrl=optionsConfirmParams.split('avatarUrl=')[1]
if '&' in optionsAvatarUrl:
optionsAvatarUrl=optionsAvatarUrl.split('&')[0]
# link to a post, which can then be included in reports
postUrl=None
if 'postUrl' in optionsConfirmParams:
postUrl=optionsConfirmParams.split('postUrl=')[1]
if '&' in postUrl:
postUrl=postUrl.split('&')[0]
optionsNickname=getNicknameFromActor(optionsActor)
if not optionsNickname:
print('WARN: unable to find nickname in '+optionsActor)
self._redirect_headers(originPathStr,cookie)
self.server.POSTbusy=False
return
optionsDomain,optionsPort=getDomainFromActor(optionsActor)
optionsDomainFull=optionsDomain
if optionsPort:
if optionsPort!=80 and optionsPort!=443:
if ':' not in optionsDomain:
optionsDomainFull=optionsDomain+':'+str(optionsPort)
if chooserNickname==optionsNickname and \
optionsDomain==self.server.domain and \
optionsPort==self.server.port:
if self.server.debug:
print('You cannot perform an option action on yourself')
if '&submitView=' in optionsConfirmParams:
if self.server.debug:
print('Viewing '+optionsActor)
self._redirect_headers(optionsActor,cookie)
self.server.POSTbusy=False
return
if '&submitBlock=' in optionsConfirmParams:
if self.server.debug:
print('Adding block by '+chooserNickname+ \
' of '+optionsActor)
addBlock(self.server.baseDir,chooserNickname, \
self.server.domain, \
optionsNickname,optionsDomainFull)
if '&submitUnblock=' in optionsConfirmParams:
if self.server.debug:
print('Unblocking '+optionsActor)
msg=htmlUnblockConfirm(self.server.translate, \
self.server.baseDir, \
originPathStr, \
optionsActor, \
optionsAvatarUrl).encode()
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
self.server.POSTbusy=False
return
if '&submitFollow=' in optionsConfirmParams:
if self.server.debug:
print('Following '+optionsActor)
msg=htmlFollowConfirm(self.server.translate, \
self.server.baseDir, \
originPathStr, \
optionsActor, \
optionsAvatarUrl).encode()
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
self.server.POSTbusy=False
return
if '&submitUnfollow=' in optionsConfirmParams:
if self.server.debug:
print('Unfollowing '+optionsActor)
msg=htmlUnfollowConfirm(self.server.translate, \
self.server.baseDir, \
originPathStr, \
optionsActor, \
optionsAvatarUrl).encode()
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
self.server.POSTbusy=False
return
if '&submitDM=' in optionsConfirmParams:
if self.server.debug:
print('Sending DM to '+optionsActor)
reportPath=self.path.replace('/personoptions','')+'/newdm'
msg=htmlNewPost(False,self.server.translate, \
self.server.baseDir, \
self.server.httpPrefix, \
reportPath,None, \
[optionsActor],None, \
pageNumber, \
chooserNickname,self.server.domain).encode()
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
self.server.POSTbusy=False
return
if '&submitSnooze=' in optionsConfirmParams:
thisActor= \
self.server.httpPrefix+'://'+self.server.domainFull+ \
self.path.split('/personoptions')[0]
if self.server.debug:
print('Snoozing '+optionsActor+' '+thisActor)
if '/users/' in thisActor:
nickname=thisActor.split('/users/')[1]
personSnooze(self.server.baseDir,nickname,self.server.domain,optionsActor)
self._redirect_headers(thisActor+ \
'/'+self.server.defaultTimeline+ \
'?page='+str(pageNumber),cookie)
self.server.POSTbusy=False
return
if '&submitUnSnooze=' in optionsConfirmParams:
thisActor= \
self.server.httpPrefix+'://'+self.server.domainFull+ \
self.path.split('/personoptions')[0]
if self.server.debug:
print('Unsnoozing '+optionsActor+' '+thisActor)
if '/users/' in thisActor:
nickname=thisActor.split('/users/')[1]
personUnsnooze(self.server.baseDir,nickname,self.server.domain,optionsActor)
self._redirect_headers(thisActor+ \
'/'+self.server.defaultTimeline+ \
'?page='+str(pageNumber),cookie)
self.server.POSTbusy=False
return
if '&submitReport=' in optionsConfirmParams:
if self.server.debug:
print('Reporting '+optionsActor)
reportPath=self.path.replace('/personoptions','')+'/newreport'
msg=htmlNewPost(False,self.server.translate, \
self.server.baseDir, \
self.server.httpPrefix, \
reportPath,None,[], \
postUrl,pageNumber, \
chooserNickname,self.server.domain).encode()
self._set_headers('text/html',len(msg),cookie)
self._write(msg)
self.server.POSTbusy=False
return
self._redirect_headers(originPathStr,cookie)
self.server.POSTbusy=False
return
self._benchmarkPOSTtimings(POSTstartTime,POSTtimings,14)
# receive different types of post created by htmlNewPost
postTypes=["newpost","newunlisted","newfollowers","newdm","newreport","newshare","newquestion"]
for currPostType in postTypes:
if currPostType!='newshare':
postRedirect=self.server.defaultTimeline
else:
postRedirect='shares'
pageNumber=self._receiveNewPost(authorized,currPostType,self.path)
if pageNumber:
nickname=self.path.split('/users/')[1]
if '/' in nickname:
nickname=nickname.split('/')[0]
self._redirect_headers(self.server.httpPrefix+'://'+self.server.domainFull+ \
'/users/'+nickname+ \
'/'+postRedirect+ \
'?page='+str(pageNumber),cookie)
self.server.POSTbusy=False
return
self._benchmarkPOSTtimings(POSTstartTime,POSTtimings,15)
if self.path.endswith('/outbox') or self.path.endswith('/shares'):
if '/users/' in self.path:
if authorized:
self.outboxAuthenticated=True
pathUsersSection=self.path.split('/users/')[1]
self.postToNickname=pathUsersSection.split('/')[0]
if not self.outboxAuthenticated:
self.send_response(405)
self.end_headers()
self.server.POSTbusy=False
return
self._benchmarkPOSTtimings(POSTstartTime,POSTtimings,16)
# check that the post is to an expected path
if not (self.path.endswith('/outbox') or \
self.path.endswith('/inbox') or \
self.path.endswith('/shares') or \
self.path.endswith('/moderationaction') or \
self.path.endswith('/caps/new') or \
self.path=='/sharedInbox'):
print('Attempt to POST to invalid path '+self.path)
self.send_response(400)
self.end_headers()
self.server.POSTbusy=False
return
self._benchmarkPOSTtimings(POSTstartTime,POSTtimings,17)
# read the message and convert it into a python dictionary
length = int(self.headers['Content-length'])
if self.server.debug:
print('DEBUG: content-length: '+str(length))
if not self.headers['Content-type'].startswith('image/') and \
not self.headers['Content-type'].startswith('video/') and \
not self.headers['Content-type'].startswith('audio/'):
if length>self.server.maxMessageLength:
print('Maximum message length exceeded '+str(length))
self.send_response(400)
self.end_headers()
self.server.POSTbusy=False
return
else:
if length>self.server.maxMediaSize:
print('Maximum media size exceeded '+str(length))
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: unauthenticated 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'
if self.headers['Content-type'].endswith('webp'):
mediaFilename=mediaFilenameBase+'.webp'
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' and \
self.headers['Content-type'] != 'application/activity+json':
print("POST is not json: "+self.headers['Content-type'])
if self.server.debug:
print(str(self.headers))
length = int(self.headers['Content-length'])
if length<self.server.maxPostLength:
unknownPost=self.rfile.read(length).decode('utf-8')
print(str(unknownPost))
self.send_response(400)
self.end_headers()
self.server.POSTbusy=False
return
if self.server.debug:
print('DEBUG: Reading message')
self._benchmarkPOSTtimings(POSTstartTime,POSTtimings,18)
# check content length before reading bytes
if self.path == '/sharedInbox' or self.path == '/inbox':
length=0
if self.headers.get('Content-length'):
length = int(self.headers['Content-length'])
elif self.headers.get('Content-Length'):
length = int(self.headers['Content-Length'])
elif self.headers.get('content-length'):
length = int(self.headers['content-length'])
if length>10240:
print('WARN: post to shared inbox is too long '+str(length)+' bytes')
self._400()
self.server.POSTbusy=False
return
messageBytes=self.rfile.read(length)
# check content length after reading bytes
if self.path == '/sharedInbox' or self.path == '/inbox':
lenMessage=len(messageBytes)
if lenMessage>10240:
print('WARN: post to shared inbox is too long '+str(lenMessage)+' bytes')
self._400()
self.server.POSTbusy=False
return
# convert the raw bytes to json
messageJson=json.loads(messageBytes)
self._benchmarkPOSTtimings(POSTstartTime,POSTtimings,19)
# https://www.w3.org/TR/activitypub/#object-without-create
if self.outboxAuthenticated:
if self._postToOutbox(messageJson,__version__):
if messageJson.get('id'):
self.headers['Location']= \
messageJson['id'].replace('/activity','').replace('/undo','')
self.send_response(201)
self.end_headers()
self.server.POSTbusy=False
return
else:
if self.server.debug:
print('Failed to post to outbox')
self.send_response(403)
self.end_headers()
self.server.POSTbusy=False
return
self._benchmarkPOSTtimings(POSTstartTime,POSTtimings,20)
# check the necessary properties are available
if self.server.debug:
print('DEBUG: Check message has params')
if self.path.endswith('/inbox') or \
self.path=='/sharedInbox':
if not inboxMessageHasParams(messageJson):
if self.server.debug:
print("DEBUG: inbox message doesn't have the required parameters")
self.send_response(403)
self.end_headers()
self.server.POSTbusy=False
return
self._benchmarkPOSTtimings(POSTstartTime,POSTtimings,21)
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
self._benchmarkPOSTtimings(POSTstartTime,POSTtimings,22)
if not inboxPermittedMessage(self.server.domain, \
messageJson, \
self.server.federationList):
if self.server.debug:
# https://www.youtube.com/watch?v=K3PrSj9XEu4
print('DEBUG: Ah Ah Ah')
self.send_response(403)
self.end_headers()
self.server.POSTbusy=False
return
self._benchmarkPOSTtimings(POSTstartTime,POSTtimings,23)
if self.server.debug:
print('DEBUG: POST saving to inbox queue')
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:
queueStatus= \
self._updateInboxQueue(self.postToNickname, \
messageJson,messageBytes)
if queueStatus==0:
self.send_response(200)
self.end_headers()
self.server.POSTbusy=False
return
if queueStatus==1:
self.send_response(503)
self.end_headers()
self.server.POSTbusy=False
return
if self.server.debug:
print('_updateInboxQueue exited without doing anything')
else:
if self.server.debug:
print('self.postToNickname is None')
self.send_response(403)
self.end_headers()
self.server.POSTbusy=False
return
else:
if self.path == '/sharedInbox' or self.path == '/inbox':
print('DEBUG: POST to shared inbox')
queueStatus= \
self._updateInboxQueue('inbox',messageJson,messageBytes)
if queueStatus==0:
self.send_response(200)
self.end_headers()
self.server.POSTbusy=False
return
if queueStatus==1:
self.send_response(503)
self.end_headers()
self.server.POSTbusy=False
return
self.send_response(200)
self.end_headers()
self.server.POSTbusy=False
class PubServerUnitTest(PubServer):
protocol_version = 'HTTP/1.0'
def runPostsQueue(baseDir: str,sendThreads: [],debug: bool) -> None:
"""Manages the threads used to send posts
"""
while True:
time.sleep(1)
removeDormantThreads(baseDir,sendThreads,debug)
def runSharesExpire(versionNumber: str,baseDir: str) -> None:
"""Expires shares as needed
"""
while True:
time.sleep(120)
expireShares(baseDir)
def runPostsWatchdog(projectVersion: str,httpd) -> None:
"""This tries to keep the posts thread running even if it dies
"""
print('Starting posts queue watchdog')
postsQueueOriginal=httpd.thrPostsQueue.clone(runPostsQueue)
httpd.thrPostsQueue.start()
while True:
time.sleep(20)
if not httpd.thrPostsQueue.isAlive():
httpd.thrPostsQueue.kill()
httpd.thrPostsQueue=postsQueueOriginal.clone(runPostsQueue)
httpd.thrPostsQueue.start()
print('Restarting posts queue...')
def runSharesExpireWatchdog(projectVersion: str,httpd) -> None:
"""This tries to keep the shares expiry thread running even if it dies
"""
print('Starting shares expiry watchdog')
sharesExpireOriginal=httpd.thrSharesExpire.clone(runSharesExpire)
httpd.thrSharesExpire.start()
while True:
time.sleep(20)
if not httpd.thrSharesExpire.isAlive():
httpd.thrSharesExpire.kill()
httpd.thrSharesExpire=sharesExpireOriginal.clone(runSharesExpire)
httpd.thrSharesExpire.start()
print('Restarting shares expiry...')
def loadTokens(baseDir: str,tokensDict: {},tokensLookup: {}) -> None:
for subdir, dirs, files in os.walk(baseDir+'/accounts'):
for handle in dirs:
if '@' in handle:
tokenFilename=baseDir+'/accounts/'+handle+'/.token'
if not os.path.isfile(tokenFilename):
continue
nickname=handle.split('@')[0]
token=None
try:
with open(tokenFilename, 'r') as fp:
token = fp.read()
except Exception as e:
print('WARN: Unable to read token for '+nickname+' '+str(e))
if not token:
continue
tokensDict[nickname]=token
tokensLookup[token]=nickname
def runDaemon(mediaInstance: bool,maxRecentPosts: int, \
enableSharedInbox: bool,registration: bool, \
language: str,projectVersion: str, \
instanceId: str,clientToServer: bool, \
baseDir: str,domain: str, \
port=80,proxyPort=80,httpPrefix='https', \
fedList=[],maxMentions=10,maxEmoji=10, \
authenticatedFetch=False, \
noreply=False,nolike=False,nopics=False, \
noannounce=False,cw=False,ocapAlways=False, \
useTor=False,maxReplies=64, \
domainMaxPostsPerDay=8640,accountMaxPostsPerDay=8640, \
allowDeletion=False,debug=False,unitTest=False, \
instanceOnlySkillsSearch=False,sendThreads=[], \
useBlurHash=False) -> None:
if len(domain)==0:
domain='localhost'
if '.' not in domain:
if domain != 'localhost':
print('Invalid domain: ' + domain)
return
if unitTest:
serverAddress = (domain, proxyPort)
pubHandler = partial(PubServerUnitTest)
else:
serverAddress = ('', proxyPort)
pubHandler = partial(PubServer)
try:
httpd = ThreadingHTTPServer(serverAddress, pubHandler)
except Exception as e:
if e.errno==98:
print('ERROR: HTTP server address is already in use. '+str(serverAddress))
return False
print('ERROR: HTTP server failed to start. '+str(e))
return False
httpd.useBlurHash=useBlurHash
httpd.mediaInstance=mediaInstance
httpd.defaultTimeline='inbox'
if mediaInstance:
httpd.defaultTimeline='tlmedia'
# load translations dictionary
httpd.translate={}
httpd.systemLanguage='en'
if not unitTest:
if not os.path.isdir(baseDir+'/translations'):
print('ERROR: translations directory not found')
return
if not language:
systemLanguage=locale.getdefaultlocale()[0]
else:
systemLanguage=language
if not systemLanguage:
systemLanguage='en'
if '_' in systemLanguage:
systemLanguage=systemLanguage.split('_')[0]
while '/' in systemLanguage:
systemLanguage=systemLanguage.split('/')[1]
if '.' in systemLanguage:
systemLanguage=systemLanguage.split('.')[0]
translationsFile=baseDir+'/translations/'+systemLanguage+'.json'
if not os.path.isfile(translationsFile):
systemLanguage='en'
translationsFile=baseDir+'/translations/'+systemLanguage+'.json'
print('System language: '+systemLanguage)
httpd.systemLanguage=systemLanguage
httpd.translate=loadJson(translationsFile)
if registration=='open':
httpd.registration=True
else:
httpd.registration=False
httpd.enableSharedInbox=enableSharedInbox
httpd.outboxThread={}
httpd.newPostThread={}
httpd.projectVersion=projectVersion
httpd.authenticatedFetch=authenticatedFetch
# max POST size of 30M
httpd.maxPostLength=1024*1024*30
httpd.maxMediaSize=httpd.maxPostLength
httpd.maxMessageLength=8000
httpd.maxPostsInBox=32000
httpd.domain=domain
httpd.port=port
httpd.domainFull=domain
if port:
if port!=80 and port!=443:
if ':' not in domain:
httpd.domainFull=domain+':'+str(port)
httpd.httpPrefix=httpPrefix
httpd.debug=debug
httpd.federationList=fedList.copy()
httpd.baseDir=baseDir
httpd.instanceId=instanceId
httpd.personCache={}
httpd.cachedWebfingers={}
httpd.useTor=useTor
httpd.session = None
httpd.sessionLastUpdate=0
httpd.lastGET=0
httpd.lastPOST=0
httpd.GETbusy=False
httpd.POSTbusy=False
httpd.receivedMessage=False
httpd.inboxQueue=[]
httpd.sendThreads=sendThreads
httpd.postLog=[]
httpd.maxQueueLength=64
httpd.ocapAlways=ocapAlways
httpd.allowDeletion=allowDeletion
httpd.lastLoginTime=0
httpd.maxReplies=maxReplies
httpd.tokens={}
httpd.tokensLookup={}
loadTokens(baseDir,httpd.tokens,httpd.tokensLookup)
httpd.instanceOnlySkillsSearch=instanceOnlySkillsSearch
httpd.acceptedCaps=["inbox:write","objects:read"]
# contains threads used to send posts to followers
httpd.followersThreads=[]
if noreply:
httpd.acceptedCaps.append('inbox:noreply')
if nolike:
httpd.acceptedCaps.append('inbox:nolike')
if nopics:
httpd.acceptedCaps.append('inbox:nopics')
if noannounce:
httpd.acceptedCaps.append('inbox:noannounce')
if cw:
httpd.acceptedCaps.append('inbox:cw')
if not os.path.isdir(baseDir+'/accounts/inbox@'+domain):
print('Creating shared inbox: inbox@'+domain)
createSharedInbox(baseDir,'inbox',domain,port,httpPrefix)
if not os.path.isdir(baseDir+'/cache'):
os.mkdir(baseDir+'/cache')
if not os.path.isdir(baseDir+'/cache/actors'):
print('Creating actors cache')
os.mkdir(baseDir+'/cache/actors')
if not os.path.isdir(baseDir+'/cache/announce'):
print('Creating announce cache')
os.mkdir(baseDir+'/cache/announce')
if not os.path.isdir(baseDir+'/cache/avatars'):
print('Creating avatars cache')
os.mkdir(baseDir+'/cache/avatars')
archiveDir=baseDir+'/archive'
if not os.path.isdir(archiveDir):
print('Creating archive')
os.mkdir(archiveDir)
print('Creating cache expiry thread')
httpd.thrCache= \
threadWithTrace(target=expireCache, \
args=(baseDir,httpd.personCache, \
httpd.httpPrefix, \
archiveDir, \
httpd.maxPostsInBox),daemon=True)
httpd.thrCache.start()
print('Creating posts queue')
httpd.thrPostsQueue= \
threadWithTrace(target=runPostsQueue, \
args=(baseDir,httpd.sendThreads,debug),daemon=True)
if not unitTest:
httpd.thrPostsWatchdog= \
threadWithTrace(target=runPostsWatchdog, \
args=(projectVersion,httpd),daemon=True)
httpd.thrPostsWatchdog.start()
else:
httpd.thrPostsQueue.start()
print('Creating expire thread for shared items')
httpd.thrSharesExpire= \
threadWithTrace(target=runSharesExpire, \
args=(__version__,baseDir),daemon=True)
if not unitTest:
httpd.thrSharesExpireWatchdog= \
threadWithTrace(target=runSharesExpireWatchdog, \
args=(projectVersion,httpd),daemon=True)
httpd.thrSharesExpireWatchdog.start()
else:
httpd.thrSharesExpire.start()
httpd.recentPostsCache={}
httpd.maxRecentPosts=maxRecentPosts
httpd.iconsCache={}
print('Creating inbox queue')
httpd.thrInboxQueue= \
threadWithTrace(target=runInboxQueue, \
args=(httpd.recentPostsCache,httpd.maxRecentPosts, \
projectVersion, \
baseDir,httpPrefix,httpd.sendThreads, \
httpd.postLog,httpd.cachedWebfingers, \
httpd.personCache,httpd.inboxQueue, \
domain,port,useTor,httpd.federationList, \
httpd.ocapAlways,maxReplies, \
domainMaxPostsPerDay,accountMaxPostsPerDay, \
allowDeletion,debug,maxMentions,maxEmoji, \
httpd.translate, \
unitTest,httpd.acceptedCaps),daemon=True)
print('Creating scheduled post thread')
httpd.thrPostSchedule= \
threadWithTrace(target=runPostSchedule, \
args=(baseDir,httpd,20),daemon=True)
if not unitTest:
print('Creating inbox queue watchdog')
httpd.thrWatchdog= \
threadWithTrace(target=runInboxQueueWatchdog, \
args=(projectVersion,httpd),daemon=True)
httpd.thrWatchdog.start()
print('Creating scheduled post watchdog')
httpd.thrWatchdogSchedule= \
threadWithTrace(target=runPostScheduleWatchdog, \
args=(projectVersion,httpd),daemon=True)
httpd.thrWatchdogSchedule.start()
else:
httpd.thrInboxQueue.start()
httpd.thrPostSchedule.start()
if clientToServer:
print('Running ActivityPub client on ' + domain + ' port ' + str(proxyPort))
else:
print('Running ActivityPub server on ' + domain + ' port ' + str(proxyPort))
httpd.serve_forever()