1 #!/usr/bin/env python3
2 from json import loads as json_loads
3 from mimetypes import guess_type
4 from os import environ
5 from pathlib import Path
6 from sys import stdout, stderr
7 from sqlite3 import connect as sqlite3_connect
8 from time import clock_gettime, CLOCK_MONOTONIC
9 from urllib.error import HTTPError, URLError
10 from urllib.parse import urlencode, urlunsplit, urljoin, urlsplit, parse_qsl, unquote, quote
11 from urllib.request import urlopen
12 from html.parser import HTMLParser
13 
14 
15 class _BaseTag:
16     def __init__(self, tag, attrs):
17         self.tag = tag
18 
19     def on_data(self, data):
20         raise AssertionError("The method must be overridden")
21 
22     def flush(self):
23         raise AssertionError("The method must be overridden")
24 
25 
26 class ParagraphTag(_BaseTag):
27     def __init__(self, tag, attrs):
28         super().__init__(tag, attrs)
29         self.content = []
30         self.footer = []
31 
32     def on_data(self, data):
33         self.content.append(data.strip())
34 
35     def flush(self):
36         result = " ".join(" ".join(data.split()) for data in self.content if data)
37         footer = self.footer
38         self.content = []
39         self.footer = []
40         return "\n".join([result] + footer) + "\n" if result else ""
41 
42 
43 class LinkTag(_BaseTag):
44     def __init__(self, href, paragraph, tag, attrs):
45         super().__init__(tag, attrs)
46         self.href = href
47         self.paragraph = paragraph
48         self.content = []
49 
50     def on_data(self, data):
51         if not self.content:
52             self.paragraph.on_data("↳")
53             self.paragraph.on_data(data)
54         self.content.append(data.strip())
55 
56     def flush(self):
57         text = " ".join(" ".join(data.split()) for data in self.content if data)
58         self.paragraph.footer.append(f"=> {self.href} {text}")
59         return ""
60 
61 
62 class LiItemTag(ParagraphTag):
63     def flush(self):
64         content = super().flush()
65         return f"* {content}" if content else ""
66 
67 
68 class QuoteTag(ParagraphTag):
69     def flush(self):
70         content = super().flush()
71         return f"> {content}" if content else ""
72 
73 
74 class HeaderTag(ParagraphTag):
75     def flush(self):
76         content = super().flush()
77         if not content:
78             return ""
79         return f"{'#' * int(self.tag[1:])} {content}"
80 
81 
82 class PreformattedTag(_BaseTag):
83     def __init__(self, tag, attrs):
84         super().__init__(tag, attrs)
85         self.content = ""
86 
87     def on_data(self, data):
88         self.content += data
89 
90     def flush(self):
91         result = self.content
92         self.content = ""
93         return f"```\n{result}\n```\n" if result else ""
94 
95 
96 class HtmlToGmi(HTMLParser):
97     def __init__(self, base_url, fn_media_url):
98         super().__init__()
99         self.gmi_text = []
100         self.stack = []
101         self.base_url = base_url
102         self.fn_media_url = fn_media_url
103 
104     def feed(self, data):
105         super().feed(data)
106         while self.stack:
107             self.gmi_text.append(self.stack.pop().flush())
108         return "\n".join(gmi_text for gmi_text in self.gmi_text if gmi_text)
109 
110     def handle_starttag(self, tag, attrs):
111         def _push(elem):
112             if self.stack:
113                 self.gmi_text.append(self.stack[-1].flush())
114             self.stack.append(elem)
115 
116         if tag == "p":
117             _push(ParagraphTag(tag, attrs))
118         elif tag == "pre":
119             _push(PreformattedTag(tag, attrs))
120         elif tag in {"h1", "h2", "h3", "h4", "h5", "h6"}:
121             _push(HeaderTag(tag, attrs))
122         elif tag in {"li", "dt"}:
123             _push(LiItemTag(tag, attrs))
124         elif tag in {"blockquote", "q"}:
125             _push(QuoteTag(tag, attrs))
126         elif tag == "a":
127             href = dict(attrs).get("href")
128             if href:
129                 self.stack.append(LinkTag(urljoin(self.base_url, href), self._get_current_paragraph(), tag, attrs))
130         elif tag == "img":
131             img = dict(attrs)
132             title = img.get("title") or ""
133             if img.get("class") == "emu" and title and self.stack:
134                 self.stack[-1].on_data(title)
135             else:
136                 src = img.get("src")
137                 if src:
138                     http_img_url = urljoin(self.base_url, src)
139                     mime, _ = guess_type(http_img_url)
140                     img_url = self.fn_media_url(mime, http_img_url)
141                     self.gmi_text.append(f"=> {img_url} {title or http_img_url}")
142         elif tag == "br":
143             if self.stack:
144                 self.gmi_text.append(self.stack[-1].flush())
145 
146     def handle_data(self, data):
147         if not self.stack:
148             self.stack.append(ParagraphTag("p", []))
149         self.stack[-1].on_data(data)
150 
151     def handle_endtag(self, tag):
152         if self.stack and tag == self.stack[-1].tag:
153             self.gmi_text.append(self.stack.pop().flush())
154 
155     def _get_current_paragraph(self):
156         for elem in reversed(self.stack):
157             if isinstance(elem, ParagraphTag):
158                 return elem
159 
160         self.stack = [ParagraphTag("p", [])] + self.stack
161         return self.stack[0]
162 
163 
164 class LonkUrl:
165     def __init__(self, raw_url):
166         self._splitted_url = urlsplit(raw_url)
167         self.splitted_path = [part for part in self._splitted_url.path.split("/") if part]
168         self.page = self.splitted_path[-1]
169         self._base_path = []
170         for path_part in self.splitted_path:
171             self._base_path.append(path_part)
172             if path_part == "lonk":
173                 break
174 
175     def build(self, page, query=""):
176         page = page if isinstance(page, list) else [page]
177         return urlunsplit(
178             ("gemini", self._splitted_url.netloc, "/".join(self._base_path + page), query, "")
179         )
180 
181     def media(self, mime, url):
182         return self.build("proxy", urlencode({"m": mime, "u": url})) if mime else url
183 
184     @property
185     def query(self):
186         return self._splitted_url.query
187 
188 
189 class HonkUrl:
190     def __init__(self, raw_url, token):
191         self._splitted_url = urlsplit(raw_url)
192         self._token = token
193 
194     def build(self, scheme=None, netloc=None, path="", query="", fragment=""):
195         return urlunsplit(
196             (
197                 scheme or self._splitted_url.scheme,
198                 netloc or self._splitted_url.netloc,
199                 path,
200                 query,
201                 fragment,
202             )
203         )
204 
205     def get(self, action, answer_is_json=True, **kwargs):
206         start_time = clock_gettime(CLOCK_MONOTONIC)
207         try:
208             query = {**{"action": action, "token": self._token}, **kwargs}
209             with urlopen(self.build(path="api", query=urlencode(query)), timeout=45) as response:
210                 answer = response.read().decode("utf8")
211                 return json_loads(answer) if answer_is_json else answer
212         finally:
213             stderr.write(f"GET {action} {kwargs}|{clock_gettime(CLOCK_MONOTONIC) - start_time:.3f}sec.\n")
214 
215 
216 def db_create_schema(db_con):
217     db_con.execute(
218         """
219         CREATE TABLE
220             client (
221                 cert_hash TEXT PRIMARY KEY,
222                 honk_url TEXT NOT NULL,
223                 token TEXT NOT NULL
224             )
225         """
226     )
227 
228 
229 def db_connect():
230     db_file_path = Path(__file__).parent / ".local" / "db"
231     db_file_path.parent.mkdir(parents=True, exist_ok=True)
232     db_exist = db_file_path.exists()
233     db_con = sqlite3_connect(db_file_path)
234     if not db_exist:
235         with db_con:
236             db_create_schema(db_con)
237     return db_con
238 
239 
240 def print_header(page_name):
241     print("20 text/gemini\r")
242     print(f"# 𝓗 onk: {page_name}\r")
243     print("\r")
244 
245 
246 def print_menu(lonk_url, honk_url, gethonks_answer=None):
247     print("## 📝 Menu\r")
248     print(f"=> {lonk_url.build('newhonk')} new honk\r")
249     print(f"=> {lonk_url.build([])} lonk home\r")
250     print(f"=> {lonk_url.build('first')} first class only\r")
251 
252     if gethonks_answer:
253         line = f"=> {lonk_url.build('atme')} @me"
254         if gethonks_answer["mecount"]:
255             line += f' ({gethonks_answer["mecount"]})'
256         print(line + "\r")
257 
258         line = f"=> {honk_url.build(path='chatter')} chatter"
259         if gethonks_answer["chatcount"]:
260             line += f' ({gethonks_answer["chatcount"]})'
261         print(line + "\r")
262 
263     print(f"=> {lonk_url.build('search')} search\r")
264     print(f"=> {lonk_url.build('longago')} long ago\r")
265     print(f"=> {lonk_url.build('myhonks')} my honks\r")
266     print(f"=> {lonk_url.build('gethonkers')} honkers\r")
267     print(f"=> {lonk_url.build('addhonker')} add new honker\r")
268     print(f"=> {lonk_url.build('digest')} digest\r")
269 
270 
271 def print_gethonks(gethonks_answer, lonk_url, honk_url):
272     print_menu(lonk_url, honk_url, gethonks_answer)
273     print("\r")
274 
275     for honk in gethonks_answer.get("honks") or []:
276         convoy = honk["Convoy"]
277         re_url = honk.get("RID")
278         oondle = honk.get("Oondle")
279         from_ = f'{oondle} (🔁 {honk["Handle"]})' if oondle else f'{honk["Handle"]}'
280         lines = [
281             f'##{"# ↱" if re_url else ""} From {from_} {honk["Date"]}',
282             f'=> {lonk_url.build("convoy", urlencode({"c": convoy}))} Convoy {convoy}',
283             f'=> {honk["XID"]}',
284         ]
285         if re_url:
286             lines.append(f'=> {re_url} Re: {re_url}')
287         lines.append("")
288         lines.append(HtmlToGmi(honk_url.build(), lonk_url.media).feed(honk["HTML"]))
289         for donk in honk.get("Donks") or []:
290             if donk.get("XID"):
291                 donk_url = honk_url.build(path=f'/d/{donk["XID"]}')
292             else:
293                 donk_url = urljoin(honk["XID"], donk["URL"])
294             donk_mime = donk["Media"]
295             lines.append(f'=> {lonk_url.media(donk_mime, donk_url)} {donk_url}')
296             donk_text = donk.get("Desc") or donk.get("Name") or None
297             if donk_text:
298                 lines.append(donk_text)
299         lines.append("")
300         if honk.get("Public"):
301             lines.append(f'=> {lonk_url.build("bonk", urlencode({"w": honk["XID"]}))} ↺ bonk')
302         honk_back_url = lonk_url.build(
303             [
304                 quote(honk["Handles"] or " ", safe=""),
305                 quote(honk["XID"], safe=""),
306                 "honkback",
307             ]
308         )
309         lines.append(f'=> {honk_back_url} ↱ honk back')
310         for xonker in (honk.get("Honker"), honk.get("Oonker")):
311             if xonker:
312                 lines.append(f'=> {lonk_url.build("honker", urlencode({"xid": xonker}))} honks of {xonker}')
313         print("\r\n".join(lines))
314         print("\r")
315 
316     if gethonks_answer.get("honks"):
317         print("\r")
318         print_menu(lonk_url, honk_url, gethonks_answer)
319 
320 
321 class _LonkTreeItem:
322     def __init__(self, honk):
323         self.honk = honk
324         self.thread = []
325 
326     def iterate_honks(self):
327         if self.honk is not None:
328             yield self.honk
329             yield from self.thread
330 
331 
332 def page_lonk(lonk_url, honk_url):
333     gethonks_answer = honk_url.get("gethonks", page="home")
334 
335     timeline = {}
336     lonk_tree = {}
337     for i, honk in enumerate(reversed(gethonks_answer["honks"])):
338         timeline.setdefault(honk["Convoy"], i)
339         if honk.get("RID"):
340             lonk_tree.setdefault(honk["Convoy"], _LonkTreeItem(None))
341         else:
342             lonk_tree[honk["Convoy"]] = _LonkTreeItem(honk)
343 
344     # fetch first 36 threads (without start honk)
345     sorted_ = sorted(timeline.keys(), key=lambda convoy: timeline[convoy], reverse=True)
346     correction_map = {}
347     for convoy in [convoy for convoy in sorted_ if lonk_tree[convoy].honk is None][:36]:
348         for honk in honk_url.get("gethonks", page="convoy", c=convoy)["honks"]:
349             if not honk.get("RID"):
350                 if convoy != honk["Convoy"]:
351                     correction_map[convoy] = honk["Convoy"]
352                     tl_weight_1 = timeline.pop(convoy)
353                     convoy = honk["Convoy"]
354                     tl_weight_2 = timeline.get(convoy)
355                     timeline[convoy] = tl_weight_1 if tl_weight_2 is None else min(tl_weight_1, tl_weight_2)
356 
357                 item = lonk_tree.get(convoy)
358                 if item is None:
359                     lonk_tree[convoy] = _LonkTreeItem(honk)
360                 elif item.honk is None:
361                     item.honk = honk
362                 break
363         else:
364             # no thread start found
365             timeline.pop(convoy)
366 
367     # link answers to thread
368     for honk in reversed(gethonks_answer.pop("honks")):
369         if honk.get("RID"):
370             item = lonk_tree.get(correction_map.get(honk["Convoy"], honk["Convoy"]))
371             if item is not None:
372                 if item.honk is not None:
373                     item.thread.append(honk)
374 
375     # build honks for page
376     gethonks_answer["honks"] = []
377     for convoy in sorted(timeline.keys(), key=lambda convoy: timeline[convoy], reverse=True):
378         item = lonk_tree[convoy]
379         if item.honk is None:
380             break # first unfetched
381         gethonks_answer["honks"] += list(item.iterate_honks())
382 
383     print_header("lonk home")
384     print_gethonks(gethonks_answer, lonk_url, honk_url)
385 
386 
387 def page_first(lonk_url, honk_url):
388     gethonks_answer = honk_url.get("gethonks", page="home")
389     gethonks_answer["honks"] = [honk for honk in gethonks_answer.pop("honks") if honk["What"] in {"bonked", "honked"}]
390     print_header("first class only")
391     print_gethonks(gethonks_answer, lonk_url, honk_url)
392 
393 
394 def page_convoy(lonk_url, honk_url):
395     query = {pair[0]: pair[1] for pair in parse_qsl(lonk_url.query)}
396     if "c" not in query:
397         print("51 Not found\r")
398         return
399 
400     gethonks_answer = honk_url.get("gethonks", page="convoy", c=query["c"])
401     print_header(f"convoy {query['c']}")
402     print_gethonks(gethonks_answer, lonk_url, honk_url)
403 
404 
405 def page_search(lonk_url, honk_url):
406     if not lonk_url.query:
407         print("10 What are we looking for?\r")
408         return
409 
410     q = unquote(lonk_url.query)
411     gethonks_answer = honk_url.get("gethonks", page="search", q=q)
412     print_header(f"search - {q}")
413     print_gethonks(gethonks_answer, lonk_url, honk_url)
414 
415 
416 def page_atme(lonk_url, honk_url):
417     gethonks_answer = honk_url.get("gethonks", page="atme")
418     print_header("@me")
419     print_gethonks(gethonks_answer, lonk_url, honk_url)
420 
421 
422 def page_longago(lonk_url, honk_url):
423     gethonks_answer = honk_url.get("gethonks", page="longago")
424     print_header("long ago")
425     print_gethonks(gethonks_answer, lonk_url, honk_url)
426 
427 
428 def page_myhonks(lonk_url, honk_url):
429     gethonks_answer = honk_url.get("gethonks", page="myhonks")
430     print_header("my honks")
431     print_gethonks(gethonks_answer, lonk_url, honk_url)
432 
433 
434 def page_honker(lonk_url, honk_url):
435     xid = {pair[0]: pair[1] for pair in parse_qsl(lonk_url.query)}.get("xid")
436     if not xid:
437         print("51 Not found\r")
438         return
439 
440     gethonks_answer = honk_url.get("gethonks", page="honker", xid=xid)
441     print_header(f"honks of {xid}")
442     print_gethonks(gethonks_answer, lonk_url, honk_url)
443 
444 
445 def page_digest(lonk_url, honk_url):
446     gethonks_answer = honk_url.get("gethonks", page="home")
447 
448     honks = {}
449     for honk in reversed(gethonks_answer["honks"]):
450         honks[honk["Convoy"]] = True
451 
452     print("20 text/gemini\r")
453     print("# 𝓗 onk: digest\r")
454     print("\r")
455     print("```\r")
456     print("AV-98+cert> tour *\r")
457     print("```\r")
458     print("\r")
459 
460     for convoy in reversed(honks.keys()):
461         print(f'=> {lonk_url.build("convoy", urlencode({"c": convoy}))} Convoy {convoy}\r')
462 
463     print("\r")
464     print("```\r")
465     print("AV-98+cert> tour *\r")
466     print("```\r")
467     print("\r")
468     print_menu(lonk_url, honk_url)
469 
470 
471 def bonk(lonk_url, honk_url):
472     what = {pair[0]: pair[1] for pair in parse_qsl(lonk_url.query)}.get("w")
473     if not what:
474         print("51 Not found\r")
475         return
476 
477     honk_url.get("zonkit",  wherefore="bonk", what=what, answer_is_json=False)
478     print(f'30 {lonk_url.build("myhonks")}\r')
479 
480 
481 def gethonkers(lonk_url, honk_url):
482     print_header("honkers")
483     print_menu(lonk_url, honk_url)
484 
485     honkers = honk_url.get("gethonkers").get("honkers") or []
486     for honker in honkers:
487         print(f'## {honker.get("Name") or honker["XID"]}\r')
488         for field_name, display_name in zip(("Name", "XID", "Flavor"), ("name", "url", "flavor")):
489             value = honker.get(field_name)
490             if value:
491                 print(f'{display_name}: {value}\r')
492         if honker.get("Flavor") == "sub":
493             print(f'=> {lonk_url.build("unsubscribe", urlencode({"honkerid": honker["ID"]}))} unsubscribe\r')
494         else:
495             print(f'=> {lonk_url.build("subscribe", urlencode({"honkerid": honker["ID"]}))} (re)subscribe\r')
496         print(f'=> {lonk_url.build("honker", urlencode({"xid": honker["XID"]}))} honks of {honker["XID"]}\r')
497         print('\r')
498 
499     if honkers:
500         print("\r")
501         print_menu(lonk_url, honk_url)
502 
503 
504 def addhonker(lonk_url, honk_url):
505     if not lonk_url.query:
506         print("10 honker url: \r")
507         return
508 
509     url = unquote(lonk_url.query)
510     try:
511         honk_url.get("savehonker", url=url, answer_is_json=False)
512         print(f'30 {lonk_url.build("gethonkers")}\r')
513     except HTTPError as error:
514         print_header("add new honker")
515         print_menu(lonk_url, honk_url)
516         print("\r")
517         print('## Error\r')
518         print(f'> {error.fp.read().decode("utf8")}\r')
519 
520 
521 def unsubscribe(lonk_url, honk_url):
522     honkerid = {pair[0]: pair[1] for pair in parse_qsl(lonk_url.query)}.get("honkerid")
523     if not honkerid:
524         print("51 Not found\r")
525         return
526 
527     url = unquote(lonk_url.query)
528     honk_url.get("savehonker", honkerid=honkerid, unsub="unsub", answer_is_json=False)
529     print(f'30 {lonk_url.build("gethonkers")}\r')
530 
531 
532 def subscribe(lonk_url, honk_url):
533     honkerid = {pair[0]: pair[1] for pair in parse_qsl(lonk_url.query)}.get("honkerid")
534     if not honkerid:
535         print("51 Not found\r")
536         return
537 
538     url = unquote(lonk_url.query)
539     honk_url.get("savehonker", honkerid=honkerid, sub="sub", answer_is_json=False)
540     print(f'30 {lonk_url.build("gethonkers")}\r')
541 
542 
543 def newhonk(lonk_url, honk_url):
544     if not lonk_url.query:
545         print("10 let's make some noise: \r")
546         return
547 
548     noise = unquote(lonk_url.query)
549     honk_url.get("honk", noise=noise, answer_is_json=False)
550     print(f'30 {lonk_url.build("myhonks")}\r')
551 
552 
553 def honkback(lonk_url, honk_url):
554     if not lonk_url.query:
555         handles = unquote(lonk_url.splitted_path[-3]).strip()
556         rid = unquote(lonk_url.splitted_path[-2])
557         print(f"10 Answer to {handles or rid}:\r")
558         return
559 
560     noise = unquote(lonk_url.query)
561     rid = unquote(lonk_url.splitted_path[-2])
562     honk_url.get("honk", noise=noise, rid=rid, answer_is_json=False)
563     print(f'30 {lonk_url.build("myhonks")}\r')
564 
565 
566 def authenticated(cert_hash, lonk_url, fn_impl):
567     db_con = db_connect()
568     row = db_con.execute("SELECT honk_url, token FROM client WHERE cert_hash=?", (cert_hash, )).fetchone()
569     if not row:
570         print(f'30 {lonk_url.build("ask_server")}\r')
571         return
572     honk_url, token = row
573     with db_con:
574         fn_impl(lonk_url, HonkUrl(honk_url, token))
575 
576 
577 def new_client_stage_1_ask_server(lonk_url):
578     if not lonk_url.query:
579         print("10 Honk server URL\r")
580         return
581     splitted = urlsplit(unquote(lonk_url.query))
582     path = [quote(urlunsplit((splitted.scheme, splitted.netloc, "", "", "")), safe=""), "ask_username"]
583     print(f'30 {lonk_url.build(path)}\r')
584 
585 
586 def new_client_stage_2_ask_username(lonk_url):
587     if not lonk_url.query:
588         print("10 Honk user name\r")
589         return
590     if len(lonk_url.splitted_path) < 3:
591         print('59 Bad request\r')
592         return
593     quoted_server = lonk_url.splitted_path[-2]
594     path = [quoted_server, quote(unquote(lonk_url.query), safe=""), "ask_password"]
595     print(f'30 {lonk_url.build(path)}\r')
596 
597 
598 def new_client_stage_3_ask_password(cert_hash, lonk_url):
599     if not lonk_url.query:
600         print("11 Honk user password\r")
601         return
602     if len(lonk_url.splitted_path) < 4:
603         print('59 Bad request\r')
604         return
605 
606     honk_url = unquote(lonk_url.splitted_path[-3])
607     post_data = {
608         "username": unquote(lonk_url.splitted_path[-2]),
609         "password": unquote(lonk_url.query),
610         "gettoken": "1",
611     }
612     with urlopen(honk_url + "/dologin", data=urlencode(post_data).encode(), timeout=15) as response:
613         token = response.read().decode("utf8")
614     db_con = db_connect()
615     with db_con:
616         db_con.execute(
617             "INSERT OR REPLACE INTO client (cert_hash, honk_url, token) VALUES (?, ?, ?)",
618             (cert_hash, honk_url, token)
619         )
620     print(f'30 {lonk_url.build([])}\r')
621 
622 
623 def proxy(mime, url):
624     with urlopen(url, timeout=10) as response:
625         stdout.buffer.write(b"20 " + mime.encode() + b"\r\n")
626         while True:
627             content = response.read(512 * 1024)
628             if not content:
629                 break
630             stdout.buffer.write(content)
631 
632 
633 def vgi(cert_hash, lonk_url):
634     if lonk_url.page == "lonk":
635         authenticated(cert_hash, lonk_url, page_lonk)
636     elif lonk_url.page == "first":
637         authenticated(cert_hash, lonk_url, page_first)
638     elif lonk_url.page == "convoy":
639         authenticated(cert_hash, lonk_url, page_convoy)
640     elif lonk_url.page == "atme":
641         authenticated(cert_hash, lonk_url, page_atme)
642     elif lonk_url.page == "search":
643         authenticated(cert_hash, lonk_url, page_search)
644     elif lonk_url.page == "longago":
645         authenticated(cert_hash, lonk_url, page_longago)
646     elif lonk_url.page == "myhonks":
647         authenticated(cert_hash, lonk_url, page_myhonks)
648     elif lonk_url.page == "honker":
649         authenticated(cert_hash, lonk_url, page_honker)
650     elif lonk_url.page == "digest":
651         authenticated(cert_hash, lonk_url, page_digest)
652     elif lonk_url.page == "bonk":
653         authenticated(cert_hash, lonk_url, bonk)
654     elif lonk_url.page == "gethonkers":
655         authenticated(cert_hash, lonk_url, gethonkers)
656     elif lonk_url.page == "addhonker":
657         authenticated(cert_hash, lonk_url, addhonker)
658     elif lonk_url.page == "unsubscribe":
659         authenticated(cert_hash, lonk_url, unsubscribe)
660     elif lonk_url.page == "subscribe":
661         authenticated(cert_hash, lonk_url, subscribe)
662     elif lonk_url.page == "newhonk":
663         authenticated(cert_hash, lonk_url, newhonk)
664     elif lonk_url.page == "honkback":
665         authenticated(cert_hash, lonk_url, honkback)
666     elif lonk_url.page == "ask_server":
667         new_client_stage_1_ask_server(lonk_url)
668     elif lonk_url.page == "ask_username":
669         new_client_stage_2_ask_username(lonk_url)
670     elif lonk_url.page == "ask_password":
671         new_client_stage_3_ask_password(cert_hash, lonk_url)
672     elif lonk_url.page == "proxy":
673         query = {pair[0]: pair[1] for pair in parse_qsl(lonk_url.query)}
674         if "m" not in query or "u" not in query:
675             print("51 Not found\r")
676         else:
677             proxy(mime=query["m"], url=query["u"])
678     else:
679         print("51 Not found\r")
680 
681 
682 def main():
683     cert_hash_ = environ.get("VGI_CERT_HASH")
684     if cert_hash_:
685         input_url = input().strip()
686         lonk_url = LonkUrl(input_url)
687         try:
688             start_time = clock_gettime(CLOCK_MONOTONIC)
689             try:
690                 vgi(cert_hash_, lonk_url)
691             finally:
692                 stderr.write(f"{cert_hash_}|{input_url}|{clock_gettime(CLOCK_MONOTONIC) - start_time:.3f}sec.\n")
693         except HTTPError as error:
694             stderr.write(f"{error}\n")
695             if error.code == 403 and lonk_url.page != "proxy":
696                 print("20 text/gemini\r")
697                 print(f"# 𝓗 onk\r")
698                 print("\r")
699                 print(f"Remote server return {error.code}: {error.reason}\r")
700                 print("\r")
701                 print("The previously issued token has probably expired. You need to authenticate again:\r")
702                 print(f'=> {lonk_url.build("ask_server")}\r')
703             else:
704                 print(f"43 Remote server return {error.code}: {error.reason}\r")
705         except URLError as error:
706             stderr.write(f"{error}\n")
707             print(f"43 Error while trying to access remote server: {error.reason}\r")
708         except TimeoutError as error:
709             stderr.write(f"{error}\n")
710             print(f"43 Error while trying to access remote server: {error}\r")
711     else:
712         stderr.write("Certificate required\n")
713         print("60 Certificate required\r")
714 
715 
716 if __name__ == '__main__':
717     main()