#!/usr/bin/env python3 """Modifiche al motore di GrumpyDove necessarie al porting Sailfish. Il motore si compila dai sorgenti originali, non da una copia modificata a mano: questo script applica le poche modifiche che servono e si ferma con un errore chiaro se un punto non si trova (sorgenti diversi da quelli attesi). Uso: patch_engine.py """ import sys from pathlib import Path # (file, testo_da_trovare, testo_nuovo, descrizione) PATCHES = [ # Il log deve poter finire dove la sandbox di Sailfish lascia scrivere: # ~/.local/state non esiste, e il motore fallirebbe in silenzio. ("mail_log.adb", ''' Dir : constant String := Ada.Environment_Variables.Value ("HOME", "") & "/.local/state/GrumpyDove";''', ''' Dir : constant String := (if Ada.Environment_Variables.Exists ("GRUMPYDOVE_LOG") then Ada.Environment_Variables.Value ("GRUMPYDOVE_LOG") else Ada.Environment_Variables.Value ("HOME", "") & "/.local/state/GrumpyDove");''', "log redirigibile con GRUMPYDOVE_LOG"), # Cancellare un messaggio sul server: \\Deleted su quel solo UID e, # quando il server ha UIDPLUS, un expunge di quello soltanto. ("imap_shim.c", "int gd_imap_append(gd_imap *s, const char *mailbox, int seen, const char *data,", '''/* Deletes one message for good. \\Deleted on that UID only, then an expunge of it alone when the server has UIDPLUS: never of what someone else marked. */ int gd_imap_remove(gd_imap *s, unsigned uid, char *why, size_t cap) { struct mailimap_set *set = mailimap_set_new_single(uid); int result; if (set == NULL) { say(why, cap, "out of memory"); return 0; } if (!store_flag(s, uid, mailimap_flag_new_deleted(), 1, why, cap)) { mailimap_set_free(set); return 0; } if (has_capability(s, "UIDPLUS")) result = mailimap_uid_expunge(s->imap, set); else result = mailimap_expunge(s->imap); mailimap_set_free(set); if (result != MAILIMAP_NO_ERROR) { say_imap(s, "EXPUNGE", result, why, cap); return 0; } return 1; } int gd_imap_append(gd_imap *s, const char *mailbox, int seen, const char *data,''', "gd_imap_remove nello shim C"), ("imap_shim.h", "int gd_imap_move(gd_imap *session, unsigned uid, const char *mailbox, char *why, size_t cap);", '''int gd_imap_move(gd_imap *session, unsigned uid, const char *mailbox, char *why, size_t cap); int gd_imap_remove(gd_imap *session, unsigned uid, char *why, size_t cap);''', "dichiarazione di gd_imap_remove"), # Un'operazione in sospeso nuova: la cancellazione. ("mail_pending.ads", " -- File was written in Goal by us: the server gets it at the next check.\n procedure Note_Copy (Goal, File : String);", ''' -- File was written in Goal by us: the server gets it at the next check. procedure Note_Copy (Goal, File : String); -- The user emptied the message out of its mailbox for good: the server -- drops it at the next check. Does nothing outside accounts. procedure Note_Delete (Path : String);''', "Note_Delete in Mail_Pending (specifica)"), ("mail_pending.adb", " procedure Note_Copy (Goal, File : String) is", ''' procedure Note_Delete (Path : String) is Uid : constant String := Uid_Of (File_Part (Path)); Box : constant String := Box_Of (Path); begin if Uid /= "" and then In_Account (Path) then -- A flag still waiting would be about a message that is going. Remove (Box, Uid & ".seen"); Remove (Box, Uid & ".unseen"); Remove (Box, Uid & ".move"); Remove (Box, Uid & ".delete"); Write (Box, Uid & ".delete", ""); Mail_Log.Write ("pending: delete " & Uid & " in " & Box); end if; exception when Error : others => Mail_Log.Write ("ERR pending: " & Ada.Exceptions.Exception_Message (Error)); end Note_Delete; procedure Note_Copy (Goal, File : String) is''', "Note_Delete in Mail_Pending (corpo)"), # Il flush delle operazioni: esegue la cancellazione sul server. ("mail_imap.adb", ' with Import, Convention => C, External_Name => "gd_imap_move";', ''' with Import, Convention => C, External_Name => "gd_imap_move"; function I_Remove (S : System.Address; Uid : unsigned; Why : System.Address; Cap : size_t) return int with Import, Convention => C, External_Name => "gd_imap_remove";''', "import di gd_imap_remove"), ("mail_imap.adb", ' elsif Kind = "move" then', ''' elsif Kind = "delete" then if Jmap then -- Lo shim JMAP non copre la cancellazione: meglio dirlo che -- dichiarare fatto quello che non si e' fatto. Channel.Put ("!" & Tab & "cannot delete a message through JMAP"); else Ok := I_Remove (S, unsigned'Value (Stem), Why'Address, Why_Size) /= 0; end if; elsif Kind = "move" then''', "esecuzione della cancellazione nel Flush"), # Un messaggio che aspetta di essere cancellato non va rinominato. ("mail_imap.adb", ''' (Is_Regular_File (Dir & Pending & "/" & Uid & ".seen") or else Is_Regular_File (Dir & Pending & "/" & Uid & ".unseen") or else Is_Regular_File (Dir & Pending & "/" & Uid & ".move"));''', ''' (Is_Regular_File (Dir & Pending & "/" & Uid & ".seen") or else Is_Regular_File (Dir & Pending & "/" & Uid & ".unseen") or else Is_Regular_File (Dir & Pending & "/" & Uid & ".delete") or else Is_Regular_File (Dir & Pending & "/" & Uid & ".move"));''', "Waiting comprende .delete"), # Anche i contatti della rubrica finiscono sotto HOME, che nella sandbox # non e' scrivibile: senza la variabile la sincronizzazione non salva # niente e riporta zero contatti, senza errore. ("mail_carddav.adb", ''' (Ada.Environment_Variables.Value ("HOME", "") & "/.local/share/GrumpyDove/books");''', ''' (if Ada.Environment_Variables.Exists ("GRUMPYDOVE_BOOKS") then Ada.Environment_Variables.Value ("GRUMPYDOVE_BOOKS") else Ada.Environment_Variables.Value ("HOME", "") & "/.local/share/GrumpyDove/books");''', "rubrica in GRUMPYDOVE_BOOKS"), # E le liste dei filtri che imparano: stesso motivo, stessa cura. ("mail_filing.adb", ''' (Ada.Environment_Variables.Value ("HOME", "") & "/.local/share/GrumpyDove/filing");''', ''' (if Ada.Environment_Variables.Exists ("GRUMPYDOVE_FILING") then Ada.Environment_Variables.Value ("GRUMPYDOVE_FILING") else Ada.Environment_Variables.Value ("HOME", "") & "/.local/share/GrumpyDove/filing");''', "liste dei filtri in GRUMPYDOVE_FILING"), # Ogni richiesta DAV nel log: senza, un 404 arrivava senza dire ne' quale # indirizzo ne' quale metodo, e non c'era modo di capirlo dall'esterno. ("mail_carddav.adb", "with Mail_Folders;", '''with Mail_Folders; with Mail_Log;''', "Mail_Log fra i with della rubrica"), ("mail_carddav.adb", ''' R.Status := Natural (Code); R.Etag := To_Unbounded_String (To_Ada (Tag));''', ''' R.Status := Natural (Code); -- Metodo, indirizzo e stato: la traccia che mancava. Mail_Log.Write ("dav: " & Method & " " & Url & " ->" & Natural'Image (R.Status)); R.Etag := To_Unbounded_String (To_Ada (Tag));''', "log delle richieste DAV"), # Svuotare il cestino: oltre a togliere il file, dirlo al server. ("mail_boxes.adb", ''' if not M.Gone then GNAT.OS_Lib.Delete_File (To_String (M.Path), Done);''', ''' if not M.Gone then -- Prima di toglierlo: la cancellazione va anche sul server, -- altrimenti il messaggio tornerebbe al controllo dopo. Mail_Pending.Note_Delete (To_String (M.Path)); GNAT.OS_Lib.Delete_File (To_String (M.Path), Done);''', "Empty propaga la cancellazione"), # Creare una cartella sul server. Make_Folder sa creare solo sotto Local # (Can_Hold = 1); per le cartelle di un account la via e' IMAP CREATE, che # nel motore esiste (Mail_Imap.I_Create) ma non e' mai accodata da nessuno. # La nota sta nel pending della INBOX dell'account e la esegue il Flush. ("mail_pending.ads", ''' -- File was written in Goal by us: the server gets it at the next check. procedure Note_Copy (Goal, File : String);''', ''' -- File was written in Goal by us: the server gets it at the next check. procedure Note_Copy (Goal, File : String); -- A mailbox to make on the server. Box is the account's INBOX, Name what -- the user called it: the next check runs IMAP CREATE. procedure Note_Make (Box, Name : String);''', "Note_Make in Mail_Pending (specifica)"), ("mail_pending.adb", ''' procedure Note_Copy (Goal, File : String) is begin''', ''' procedure Note_Make (Box, Name : String) is begin if In_Account (Box) and then Name /= "" then Write (Box, Name & ".mkdir", Name); Mail_Log.Write ("pending: mkdir " & Name & " in " & Box); end if; exception when Error : others => Mail_Log.Write ("ERR pending: " & Ada.Exceptions.Exception_Message (Error)); end Note_Make; procedure Note_Copy (Goal, File : String) is begin''', "Note_Make in Mail_Pending (corpo)"), # Il Flush esegue la creazione. "Esiste gia'" non e' un guasto: la # cartella c'e', che e' quello che l'utente voleva. ("mail_imap.adb", ''' elsif Kind = "delete" then''', ''' elsif Kind = "mkdir" then declare Wanted : constant String := Read_File (Path); New_Box : chars_ptr := New_String (Wanted); begin Ok := C_Create (S, New_Box, Why\'Address, Why_Size) /= 0; if not Ok then declare Said : constant String := To_Ada (Why); begin Ok := Ada.Strings.Fixed.Index (Said, "ALREADYEXISTS") > 0 or else Ada.Strings.Fixed.Index (Said, "already exists") > 0; end; end if; if not Ok then Channel.Put ("!" & Tab & Clean (Name) & ": create " & Clean (Wanted) & ": " & To_Ada (Why)); end if; Free (New_Box); end; elsif Kind = "delete" then''', "ramo mkdir nel Flush"), ] def main() -> int: if len(sys.argv) != 2: print("uso: patch_engine.py ", file=sys.stderr) return 2 src = Path(sys.argv[1]) if not (src / "mail_boxes.adb").exists(): print(f"{src}: non sembrano i sorgenti di GrumpyDove", file=sys.stderr) return 1 for nome, vecchio, nuovo, descrizione in PATCHES: f = src / nome testo = f.read_text() # Il nuovo testo contiene spesso quello vecchio: la presenza del nuovo # basta a dire che la patch c'e' gia' (senza, si applicava due volte e # finiva in "conflicts with declaration"). if nuovo in testo: print(f"giĆ  applicata: {descrizione}") continue if vecchio not in testo: print(f"NON TROVATO in {nome}: {descrizione}", file=sys.stderr) return 1 f.write_text(testo.replace(vecchio, nuovo, 1)) print(f"applicata: {descrizione}") return 0 if __name__ == "__main__": sys.exit(main())