Nuper, nuntia quomodo bona Telegrammi sit, quam splendide et periti fratres Durov in systematis retis construendis etc. saepius in Habré apparere inceperunt. Eodem tempore paucissimi homines vere se in technica arte immerserunt -, ut plurimum, satis simplici (et longe a MTProto diversum) Bot API JSON innixum, ac plerumque tantum accipiunt. in fide omnes laudes et PR circum nuntio. Fere anno et dimidio ante, collega meus apud Eshelon NGO Vasily (proh dolor, in Habré eius ratio una cum captura erasa est) scribere coepit clientem suum Telegram de integro in Perl, et postea auctor horum versuum iunctis. Quid, Perl, Quid statim rogas? Quia huiusmodi incepta iam in aliis linguis exsistunt., re vera, hoc non est, alia lingua esse potuit ubi nulla est. paratus facta bibliothecaEt ideo oportet quod auctor omni via vadat a VULNUS. Praeterea cryptographia est fiduciae, sed verificandum. Producto ad securitatem intento, bibliothecam paratam a fabricante simpliciter inniti non potes, et temere illi crede (tamen est thema secundae partis). In momento, bibliotheca satis bene in gradu "mediocris" operatur (permittit te ut API petitiones aliquas facias).

Nihilominus non multae cryptographiae vel math in hac paginarum serie erunt. Sed multae aliae technicae notae et fusae architecturae erunt (utilissimae etiam iis qui de integro non scribent, sed bibliotheca quavis lingua utentur). Itaque praecipuum propositum erat clientem a scabere efficere secundum publica documenta. Hoc est, sumamus fontem clientium officialium codicem esse clausum (iterum in secunda parte fusius argumenti illius quod verum est, operiemus. accidit ita), sed, sicut in antiquis diebus, exempli gratia, signum est RFC simile - potestne scribere clientem secundum solam specificationem, "sine inspectione" in fonte codici, officialis esto (Telegram Desktop; mobili), an Telethon priyatus?

Tabula contentorum:

Documenta... exstat, vox? An verum est?..
Ubi committitur auctor iuvenis?
Binarii serializationis: TL (Type Language) eiusque schema, strationes, et multa alia verba scaryizandi
MT Proto
API?
Tertia pars sequetur?

Documenta... exstat, vox? An verum est?..

Fragmenta notarum ad hunc articulum proxima aestate colligenda inceperunt. Hoc totum in rutrum https://core.telegram.org Documentation was as of Lay 23, i.e. alicubi haesit in 2014 (memini, ne tunc quidem canales erant?). Utique in doctrina, hoc permisit ut clientem functionis tunc temporis in MMXIV efficeret. Sed etiam in hoc statu documentum fuit primo, incompletum, secundo, in locis sibi contradicentibus. Modo supra mensem ante, mense Septembri MMXIX, erat accidens Inventum est magna renovatio documentorum in situ, ad recentem tabulam 105, cum nota quae nunc omnia denuo legi debent. Multi quidem articuli refecti sunt, sed multa immutata manserunt. Quapropter, cum criticam infra de documentis perlegas, memineris oportet quaedam ex his non amplius esse, sed quaedam adhuc plane esse. Post omnes, quinque annos in mundo huius temporis non tantum diu est, sed ipsum multum. Cum temporibus illis (praesertim si non consideres locorum geochatiorum abiectis et revivistis cum tum), numerus API methodorum in schemate ab centum ad plus quam ducentos quinquaginta crevit!

Ubi committitur auctor iuvenis?

Non refert utrum de scabere scribas an usu, exempli gratia, bibliothecae paratae factae Telethon pro Pythone aut Madeline for PHPutique primo opus erit applicationem subcriptio tuum - ut parametri api_id и api_hash (qui cum VKontakte API laboraverunt statim intellegunt) quibus ministrans applicationem cognoscet. Hoc habere legalibus rationibus id fac, sed plura loquemur de quare in secunda parte bibliothecæ auctores publici iuris facere non possunt. Contenti esse potes cum valoribus probativis, quamvis valde limitatis - re vera nunc subcriptio potes nisi unus app, ne in illud praeceps ruat.

Nunc, ex parte technica, hoc ipsum esse debet quod post adnotationem notificationes ab Telegram acciperemus de renovationibus ad documentum, protocollum, etc. Hoc est, quis posset assumere locum cum navalibus simpliciter relictum esse, et specialiter operari cum illis qui clientes facere coeperunt, quia Facilius est. Sed nulla, nihil simile observatum, nihil compertum est.

Et si de integro scribis, tum parametris utens adeptus est actu adhuc longe. Etsi https://core.telegram.org/ et de illis loquitur in primo omnium initii Questus, immo primum habebis ad effectum deducendi MTProto protocol - sed si credidisti layout secundum exemplar OSI in fine paginae descriptionis generalis protocolli, tunc omnino frustra est.

Re quidem vera, tam ante quam post MTProto, in pluribus gradibus simul (sicut networkers exteri in OS nucleo laborantes dicunt, iacuit violationem), locus magnus, dolorosus et terribilis erit in via...

Binarii serializationis: TL (Type Language) eiusque schema, strationes, et multa alia verba scaryizandi

Hic locus, re vera, clavis quaestionum Telegrammi est. Et multa verba terribilia erunt si in eam intromittere coneris.

Ita hic est tabula. Si hoc verbum in mentem venerit, dic; JSON SchemaRecte cogitasti. Propositum idem est: aliquam linguam describere possibilis notitiae transmissae. ubi similitudines finis est. Si ex pagina MTProto protocolaut e fonte arboris clientis officialis schema aliquod conabimur aperire, aliquid simile videbimus;

int ? = Int;
long ? = Long;
double ? = Double;
string ? = String;

vector#1cb5c415 {t:Type} # [ t ] = Vector t;

rpc_error#2144ca19 error_code:int error_message:string = RpcError;

rpc_answer_unknown#5e2ad36e = RpcDropAnswer;
rpc_answer_dropped_running#cd78e586 = RpcDropAnswer;
rpc_answer_dropped#a43ad8b7 msg_id:long seq_no:int bytes:int = RpcDropAnswer;

msg_container#73f1f8dc messages:vector<%Message> = MessageContainer;

---functions---

set_client_DH_params#f5045f1f nonce:int128 server_nonce:int128 encrypted_data:bytes = Set_client_DH_params_answer;

ping#7abe77ec ping_id:long = Pong;
ping_delay_disconnect#f3427b8c ping_id:long disconnect_delay:int = Pong;

invokeAfterMsg#cb9f372d msg_id:long query:!X = X;
invokeAfterMsgs#3dc4b4f0 msg_ids:Vector<long> query:!X = X;

account.updateProfile#78515775 flags:# first_name:flags.0?string last_name:flags.1?string about:flags.2?string = User;
account.sendChangePhoneCode#8e57deb flags:# allow_flashcall:flags.0?true phone_number:string current_number:flags.0?Bool = auth.SentCode;

Qui hoc primum intuenti cognosci poterit nisi partem eorum quae scriptae sunt, — hae sunt apparentiae structurae (quamvis ubi nomen est a sinistris vel a dextris?), in illis sunt agri; post quem typum sequitur colon... probabiliter. Hic in angulo uncis exstant probabiliter exempla sicut in C++ neque ita prorsus,). Et quid significant omnia alia symbola, interrogationes notas, exclamationes notas, percentages, notas detrahentes (et plane diversa in diversis locis significant), interdum praesentes, interdum non, numeri hexadecimales, ac potissimum, quomodo inde iustum (quod a servo non rejicitur) byte amnis? Documenta legere habebis (ita, nexus sunt schematis in versione JSON prope - sed clarius id non facit).

Aperi paginam Binarii Data Serialization et in magicam fungorum mundum et mathematicam discretam, quid simile matan in quarto anno intendere. Alphabetum, genus, valorem, combinator, muneris combinator, forma normalis, genus compositum, genus polymorphicum... et haec omnia prima pagina tantum! Next te manet TL Languagequae, licet iam exemplum continet parvae petitionis et responsionis, nihil omnino praebet responsio ad casus typicos, id quod significatum habebis per narrationem mathematicam ex Russica in Anglicam translatam in octo infixas. paginae!

Lectores familiares linguis functionis et generis illationis automatariae, videbunt sane descriptionem linguae in hac lingua, etiam ab exemplo, multo magis familiarem, ac dicere possunt hoc actu non esse malum in principio. Obiecta sunt:

Ita, propositum bene sonat, sed eheu! non effectum
Educatio in universitatibus Russicis variat etiam inter proprias IT proprias - non omnes sibi congruentes cursus
Denique, ut videbimus, in usu est Quod non requiratur, cum tantum subsessium limitatum etiam TL qui descriptus est usus sit

sicut locutus LeoNerd in alveum suum #perl in retis FreeNode IRC, qui portam a Telegram ad Matrix efficere conatus est (translatio loci a memoria impropria est);

Sentit ut aliquis primum theoriae genus introductus, concitatus est, et cum eo agere coepit, non vere curans an in praxi opus esset.

Vide tibi, si opus est generum nudis (int, longis, etc.) ut elementum aliquod quaestiones non moveat - finaliter manually perficienda sunt - exempli gratia, conatum ab eis sumamus. vector. Id est enim. ordinatasi propriis nominibus res consequentes vocas.

Sed ante

Brevis descriptio subset TL syntaxis illis qui documenta publica non legunt

constructor = Type;
myVec ids:Vector<long> = Type;

fixed#abcdef34 id:int = Type2;

fixedVec set:Vector<Type2> = FixedVec;

constructorOne#crc32 field1:int = PolymorType;
constructorTwo#2crc32 field_a:long field_b:Type3 field_c:int = PolymorType;
constructorThree#deadcrc bit_flags_of_what_really_present:# optional_field4:bit_flags_of_what_really_present.1?Type = PolymorType;

an_id#12abcd34 id:int = Type3;
a_null#6789cdef = Type3;

Definitio semper incipit excogitatorisad libitum, per symbolum # oportet CRC32 ex descriptione chorda normalized huiusmodi. Proximum est descriptum agrorum: si sint, genus vacuum esse potest. Haec omnia cum pari signo terminantur, ad quod nomen huius generis constructor hoc est subtypus revera pertinet. Aequalium ius signum est amet polymorphic - id est, plures species specificae ei respondere possunt.

Si definitio fit secundum lineam ---functions---ergo syntax eadem remanebit, sed sensus diversus erit: constructor fiet nomen functionis RPC, agri parametri fient (bene, hoc est, remanebit prorsus eadem structura data, de qua infra. , haec simpliciter significatio erit assignata), ac "typus polymorphicus" - typus reditus eventus. Verum, adhuc remanebit polymorphicus - modo in sectione definitus ---types---hic vero conditor non « considerari potest ». Onerare rationes dicuntur functiones suas rationes, i.e. Horum autem plures functiones eiusdem nominis, sed signaturae diversae, ut in C++, non providentur in TL.

Cur "structor" et "polymorphicus" si non est OOP? Re quidem vera, facilius erit quis cogitare de hoc in terminis OOP - genus polymorphicum sicut genus abstractum, et conditores sunt eius genera descendentia directa; final in terminologia plurium linguarum. Nam hic quidem simile cum methodis realibus constructoris in OO programmandi linguis cumulatis. Cum hic iustae sint notitiae structurae, nullae sunt methodi (quamvis descriptio functionum et methodorum adhuc satis capax est ad confusionem in capite quod existunt, sed aliud quod est) - cogitare potes de conditore ut valorem e. quod " construitur byte amnis typus cum legere.

Quomodo hoc fiet? Deserialiser, qui semper 4 bytes legit, valorem videt 0xcrc32 - et intelligit quid deinde field1 cum genus int, i.e. 4 bytes exacte legit, in hoc superiori campo cum typo PolymorType legere. Vides 0x2crc32 et intelligat duos agros esse ulterius, primo longquod interpretatur 8 bytes. Et iterum genus multiplex, quod similiter deseriatur. Exempli gratia Type3 in circuitu declarari posse, cum primum duo artifices, tum ambo congrediantur 0x12abcd34, post- quam legere debes 4 bytes intuel 0x6789cdefpost quem nihil erit. Quidquid aliud - exceptionem iactare debes. Usquam, post hoc regredimur ad lectionem 4 bytes . int agri field_c в constructorTwo et cum hoc finimus lectionem nostram PolymorType.

Denique si vos adepto deprensus 0xdeadcrc ad constructorThreetum omnia fiunt intricata. Primus ager est bit_flags_of_what_really_present cum genus # - re vera, hoc est alias pro typo natet, quod est numerus naturalis. Hoc est enim int unsigned obiter, nisi quando numeri non signati in circulis realibus occurrunt. Proxima ergo constructio cum interrogatione notatur, significans hunc campum - in filo tantum praesens erit si respondens frenum positum in agro de quo agitur (proxime sicut operante ternario). Hoc igitur frenum positum sumamus, quod significat adhuc agrum similem legere necesse est Typequem in exemplo nostro habet II constructor. Una vacua est, altera tantum campum habet ids cum genus ids:Vector<long>.

Putares utrumque exempla et genera in prosa vel Java. Sed non. Fere. Hoc tantum casus angulus uncis utendi in circuitibus realibus, et solum pro Vector adhibetur. In byte rivo, hi erunt 4 CRC32 bytes pro ipso vectore speciei, semper idem, deinde 4 bytes numero elementorum ordinata, et deinde ipsa elementa.

Huc adde quod serializationem in vocibus 4 bytes semper evenire, omnia genera eius multiplicationes sunt, quae etiam in speciebus aedificatis describuntur. bytes и string cum manuali serializatione longitudinis et alignment per 4 - bene, videtur sonare normalem et etiam relative efficacem? Tametsi TL declaratur efficax serialization binarius, cum illis infernum, cum evolutione circa res, etiam valores Booleanos ac chordarum singularum characterum ad 4 bytes, adhuc multo crassior erit JSON? Vide, etiam agros supervacuos cum frustula vexillis omitti possunt, omnia satis bona sunt, et etiam in futurum extensa, cur non novos agros libitum conditori postea addas?..

Sed noli, si legas, non brevem descriptionem meam, sed documenta plenam, et de exsecutione cogita. Uno modo, CRC32 constructoris computatur secundum lineam normalizatam textus descriptionis schematis (removeo extra whitespace, etc.) - ita si novus campus addatur, genus descriptionis linea mutabit, et inde eius CRC32 et consequenter, serialization. Et quid faceret senex cliens, si agrum novis vexillis acciperet, et quid cum iis faceret postea ignorat?

Secundo mementote CRC32quae essentialiter hic ponitur Nullam munera unice determinare quale genus est videre. Hic ponitur circa problema colliculorum - et non est probabilitas non una in 232, sed multo maior. Quis recordatus est CRC32 dispositum esse errores in canali communicationis deprehendere (et corrigere) ac proinde has proprietates in aliorum detrimentum emendare? Exempli gratia, de bytes permutando non curat: si CRC32 a duabus lineis numeras, in secundo pers 4 bytes primam cum 4 bytes altera - idem erit. Cum initus est chordarum textus ex alphabeto latino (et aliquantulum interpunctione), et haec nomina non sunt singulariter temere, probabilis talis ordinatio multum augetur.

Viam quis sedavit quid ibi erat? rem CRC32? Unus e primis codicibus fons (etiam ante Waltman) munus detrahens habuit, qui singulas characterum numero 239 multiplicavit, ut ab his hominibus dilectus, ha ha!

Denique bene intelleximus constructores generis agri Vector<int> и Vector<PolymorType> aliud erit CRC32. Quid de online perficientur? Et ex parte speculativa; haec pars generis facti? Dicamus nos decem milium numerorum aciem transeamus, bene Vector<int> omnia plana sunt, longitudo et alia 40000 bytes. quid si hoc Vector<Type2>quae est unius campi int et sola est in typo - 10000xabcdef0 34 vicibus repetere necesse est ac deinde 4 bytes intaut lingua a conditore pro nobis inpendere potest fixedVec et pro 80000 bytes, iterum tantum 40000 transfer?

Non est haec quaestio otiosa theoretica - existimare te accipias indicem usorum gregum, quorum quisque id, primum nomen, nomen novissimum habet - differentiam quantitatem notitiarum per nexum mobilem translatum significans esse potest. Ipsa efficacia telegraphi serializationis nobis proscribitur.

Ita ...

Vector, qui numquam dimittitur

Si per paginas descriptionis combinatorum et sic porro transire conaris, vector (et etiam matrix) formaliter per tuplas plurium schedae output esse conaris. Sed in fine obliviscuntur, ultimus gradus praetermittitur, et definitio vectoris simpliciter datur, quae typo nondum ligatur. Quid rei est? In linguis programmingpraesertim functiones, satis proprie est structuram recursivere describere — compilator cum sua pigra aestimatione intelleget omniaque ipsa faciet. In lingua notitia serialization quod opus est efficacia; satis est simpliciter describere album, i.e. structura duorum elementorum - primum elementum est data, alterum eadem structura vel spatium vacuum caudae (pack (cons) in Lisp). Sed hoc manifesto require quisque elementum additicium 4 bytes (CRC32 in casu TL) ut suum genus describet. Ordinata etiam facile describi potest certa magnitudinesed in rebus incertis praegressis, abrumpitur.

Ergo, cum TL non permittit vectorem exuti, in parte addendum erat. Denique documenta dicit:

Serialization eodem constructore "vector" semper utitur (const 0x1cb5c415 = crc32("vector t:Type # [t ] = Vector t") quae non dependet a valore specifico variabilis speciei t.

Valor parametri t libitum non implicatur in serializatione, quia derivatur ab eventu speciei (semper ante deserializationem notum).

Propius inspice: vector {t:Type} # [ t ] = Vector t - sed nusquam Ipsa definitio haec non dicit quod primus numerus est aequalis longitudini vectoris! Et aliunde non venit. Hoc datum est ut mente retineatur et manibus impleatur. Alibi documenta etiam honeste ponit rationem realem non esse;

Vector t polymorphicus pseudotypus est "type" cuius valor series valorum cuiuslibet generis t, vel cohibenti vel nudo.

... sed non dolor. Cum tu taedio pervagandi mathematicam (fortasse etiam notum tibi ex universitate) volueris cedere et actu spectare quomodo in praxi cum operetur, impressio in capite tuo relinquitur quod hoc est Serium. Mathematica in media, a Cool People (duo mathematici - ACM victor), et non unus clare inventa fuit. Propositum — ostentationis — consecutum est.

Uia de numero. Admonemus te quod # suus 'a synonym' natnumerus naturalis:

Sunt expressiones generis (typus-expr) Et numerorum (nat-expr). Sed eodem modo definiuntur.
type-expr ::= expr
nat-expr ::= expr
sed in grammatica eodem modo describuntur, i.e. Haec differentia iterum memorari debet et manualiter in exsequendum deduci.

Bene, ita, exemplaria template (vector<int>, vector<User>) Commune identifier (#1cb5c415) i.e. si scias quod vocatus nuntiatur

users.getUsers#d91a548 id:Vector<InputUser> = Vector<User>;

tunc iam non exspectas vectorem sed vectorem utentium. Pressius, oportet, exspectamus - in reali codice, omne elementum, nisi nudum genus, conditorem habebit et bono modo in exsequenda reprimere oporteret - sed prorsus missi sumus in omni elemento huius vectoris. quod genus? Quid, si esset aliqua PHP, in qua ordinata continere potest diversas species in diversis elementis?

Hic incipis cogitare - estne talis TL necessaria? Forsitan plaustro fieri posset serializer, isdem protobuf iam tunc exstitit? Theoria fuit, inspice praxim.

Existens TL implementations in codice

TL in profundis VKontakte natus est etiam ante eventus claros cum venditione portionis Durov et (Forsitan) etiam ante evolutionem Telegram coepisse. Et in aperto fonte source code primae implementation multum ridiculam fusum invenire potes. Et lingua ipsa ibi plenius effecta est quam nunc est in Telegram. Exempli gratia, haehes omnino non adhibentur in schemate (significatur constructo-in pseudotypo (sicut vector) cum moribus deviantibus). Or

Templates are not used now. Instead, the same universal constructors (for example, vector {t:Type} [t] = Vector t) are used w

sed perfectionis causa perpendamus evolutionem gigantis cogitationis, ut ita dicam.

#define ZHUKOV_BYTES_HACK

#ifdef ZHUKOV_BYTES_HACK

/* dirty hack for Zhukov request */

Aut haec formosa ;

    static const char *reserved_words_polymorhic[] = {

      "alpha", "beta", "gamma", "delta", "epsilon", "zeta", "eta", "theta", NULL

      };

Hoc fragmentum est de exemplaribus similibus:

intHash {alpha:Type} vector<coupleInt<alpha>> = IntHash<alpha>;

Haec est definitio generis hashmap templates sicut vector int - Type paria. In C++ simile aliquid spectaret:

    template <T> class IntHash {
      vector<pair<int,T>> _map;
    }

sic, alpha - keyword! Sed solum in C ++ scribis T, sed scribere debes alpha, beta... Sed non plus quam 8 parametri, ubi phantasia desinit. Videtur quod dialogi aliquot Petropolitani olim sic evenerunt;

-- Надо сделать в TL шаблоны
-- Бл... Ну пусть параметры зовут альфа, бета,... Какие там ещё буквы есть... О, тэта!
-- Грамматика? Ну потом напишем

-- Смотрите, какой я синтаксис придумал для шаблонов и вектора!
-- Ты долбанулся, как мы это парсить будем?
-- Да не ссыте, он там один в схеме, захаркодить -- и ок

Sed haec erat fere prima exsecutio TL "in generali". Ad effectum deducendi in ipsis clientibus Telegram transeamus.

Verbum ad Vasily:

Vasily, [09.10.18 17:07] Asinus maxime calidus est, quia fasciculum abstractionis creaverunt, et postea in eis fulmen tundebat, et codicem generantis fustibus tegebat.
Quam ob rem primum a navale gubernatore.jpg
Deinde ex codice dzhekichan.webp

Utique, ab hominibus algorithmis et mathematicis notis, sperare possumus se legisse Aho, Ullmann, et instrumenta notissima facta sunt, quae norma factae sunt in industria per decennia scribendi eorum DSL compilatores, ius?...

By telegraphum-cli Vitaly Valtman est, ut intellegi potest ex occursu formarum TLO extra eius limites, membrum consors - nunc bibliothecae TL parsing sortita est. seorsumquid est impressio eius TL parser? ..

16.12 04:18 Vasily: Puto aliquem non dominum lex+yacc
16.12 04:18 Vasily: aliter explicare non possum
16.12 04:18 Vasily: bene vel numerati sunt pro numero versuum in VK
16.12 04:19 Vasily: 3k+ lines etc.<censored> loco Total

Forsitan exceptio? Videamus quomodo делает Hic est cliens officialis - Desktop Telegram:

    nametype = re.match(r'([a-zA-Z.0-9_]+)(#[0-9a-f]+)?([^=]*)=s*([a-zA-Z.<>0-9_]+);', line);
    if (not nametype):
      if (not re.match(r'vector#1cb5c415 {t:Type} # [ t ] = Vector t;', line)):
         print('Bad line found: ' + line);

1100+ lineis in Pythone, duobus expressionibus regularibus + casuum specialium quasi vector, qui utique declaratur in schemate secundum syntaxin TL esse debere, sed in hac syntaxi ad parse ... nitebantur. Quaeritur, cur hoc totum miraculum fuit?иPropius est si nemo eam ad partes secun- dum documenta usquam?!

Viam... Memento nos de CRC32 annotando collocuti? Itaque in codice telegrapho Desktop generantis ponitur index exceptionum pro illis speciebus in quibus CRC32 computatae sunt. non congruit uno in schemate indicato!

Vasily, [18.12/22 49:XNUMX] et hic putem utrum tale TL opus sit
si tatam cum alternatione exsecutioni mandare vellem, mae lineae inserendae incipiam, dimidium parsers in multi-linearum definitionum comminuet.
tdesktop, however, too

Memini punctum unius linei, ad id paulo post revertemur.

Bene, telegraphum privatum est, Telegram Desktop officialis est, sed quid de aliis? Quis scit?... In cliente Android schismatis parser nullum omnino fuit (quod interrogationes de fonte aperto movet, sed hoc pro altera parte), sed multa alia erant ridicula codicis fragmenta, sed plura in iis. infra ordinem.

Quae aliae quaestiones serializationem in praxi excitant? Verbi gratia, multum rerum fecerunt, scilicet, cum bl agros et agros conditionales;

Vasily: flags.0? true
significat agrum praesentem et aequalem, si vexillum positum

Vasily: flags.1? int
significat quod ager praesens est et indiget deserialized

Vasily: Asine, ne cures quid vales!
Vasily: Alicubi memoratur in doc quod verum est nudum genus nulla longitudo, sed aliquid ex doc convenire non potest.
Vasily: In fonte aperto exsecutiones hoc non contingit, sed fasciculum fusum sunt et subsidia.

Quid de Telethon? Prospiciens ad argumentum MTProto, exemplum - in documentis tales sunt partes, sed signum % nonnisi descriptum est quod datae nudo generi respondeat, i.e. in exemplis infra aut error est aut undocumentus;

Vasily, [22.06.18 18:38] Uno loco:
msg_container#73f1f8dc messages:vector message = MessageContainer;
In alia:
msg_container#73f1f8dc messages:vector<%Message> = MessageContainer;
Et hae duae magnae differentiae sunt, in vita reali quidam quidam vector nudus venit

Nudum vector definitionem non vidi nec per unum

Analysis scribitur manu in telethon

In eius schemate definitio commentatur msg_container

Iterum manet quaestio de %. Non describitur.

Vadim Goncharov, [22.06.18 19:22] et in tdesktop?

Vasily, [22.06.18 19:23] At vero librarum librarum turonensium regularium machinarum hoc vel maxime verisimile non erit.

// parsed manually

TL pulchra est abstractio, nemo omnino eam operatur

Et % non est in versione eorum

Sed hic contradicit documenta, sic idk

Inventum in grammatica, simpliciter obliti sunt semanticorum describere

Documentum in TL vidisti, non potes eum videri sine sextario dimidia

"Bene, dicamus," dicet alius lector, "aliquid reprehendis, et quomodo id fiat ostende."

Vasily respondet: "Quam ad Total, mihi similia sunt"

    args: /* empty */ { $$ = NULL; }
        | args arg { $$ = g_list_append( $1, $2 ); }
        ;

    arg: LC_ID ':' type-term { $$ = tl_arg_new( $1, $3 ); }
            | LC_ID ':' condition '?' type-term { $$ = tl_arg_new_cond( $1, $5, $3 ); free($3); }
            | UC_ID ':' type-term { $$ = tl_arg_new( $1, $3 ); }
            | type-term { $$ = tl_arg_new( "", $1 ); }
            | '[' LC_ID ']' { $$ = tl_arg_new_mult( "", tl_type_new( $2, TYPE_MOD_NONE ) ); }
            ;

quodammodo placet melius

struct tree *parse_args4 (void) {
  PARSE_INIT (type_args4);
  struct parse so = save_parse ();
  PARSE_TRY (parse_optional_arg_def);
  if (S) {
    tree_add_child (T, S);
  } else {
    load_parse (so);
  }
  if (LEX_CHAR ('!')) {
    PARSE_ADD (type_exclam);
    EXPECT ("!");
  }
  PARSE_TRY_PES (parse_type_term);
  PARSE_OK;
}

aut

        # Regex to match the whole line
        match = re.match(r'''
            ^                  # We want to match from the beginning to the end
            ([w.]+)           # The .tl object can contain alpha_name or namespace.alpha_name
            (?:
                #             # After the name, comes the ID of the object
                ([0-9a-f]+)    # The constructor ID is in hexadecimal form
            )?                 # If no constructor ID was given, CRC32 the 'tl' to determine it

            (?:s              # After that, we want to match its arguments (name:type)
                {?             # For handling the start of the '{X:Type}' case
                w+            # The argument name will always be an alpha-only name
                :              # Then comes the separator between name:type
                [wd<>#.?!]+  # The type is slightly more complex, since it's alphanumeric and it can
                               # also have Vector<type>, flags:# and flags.0?default, plus :!X as type
                }?             # For handling the end of the '{X:Type}' case
            )*                 # Match 0 or more arguments
            s                 # Leave a space between the arguments and the equal
            =
            s                 # Leave another space between the equal and the result
            ([wd<>#.?]+)     # The result can again be as complex as any argument type
            ;$                 # Finally, the line should always end with ;
            ''', tl, re.IGNORECASE | re.VERBOSE)

Tota lexer haec est:

    ---functions---         return FUNCTIONS;
    ---types---             return TYPES;
    [a-z][a-zA-Z0-9_]*      yylval.string = strdup(yytext); return LC_ID;
    [A-Z][a-zA-Z0-9_]*      yylval.string = strdup(yytext); return UC_ID;
    [0-9]+                  yylval.number = atoi(yytext); return NUM;
    #[0-9a-fA-F]{1,8}       yylval.number = strtol(yytext+1, NULL, 16); return ID_HASH;

    n                      /* skip new line */
    [ t]+                  /* skip spaces */
    //.*$                 /* skip comments */
    /*.**/              /* skip comments */
    .                       return (int)yytext[0];

illae. simplicius mitius ponit. "

In genere, ergo, parser et codice generantis pro usu copiae TL aptae in lineas grammatices circiter 100 et ~ 300 lineas generantis (omnibus computatis. printcodice generati), inter informationes generis Cuniculi ad introspectionem in unaquaque classe. Quodlibet genus polymorphicum in genus turpem abstractum inane vertit, et conditores inde possident ac methodos habent pro serializatione et deserializatione.

Nullam typus in lingua genus

Fortis typing est bona res, vox? Imo non est holivaria (quamvis linguas dynamicas praefero), sed postulatum intra TL compage. Ex ea lingua omnibus impedimentis pro nobis providere debet. Bene, purus, non ipsum, sed turpis, sed vel ipsum. Quales occasiones velimus?

Imprimis angustiis. Hic perspicimus in documentis ad fasciculos discendi:

Contentum binarium fasciculi tunc in partes scinditur. Omnes partes eiusdem quantitatis sunt ( part_size ) et sequentibus conditionibus occurrendum est:

part_size % 1024 = 0 (divisibile per 1KB)

524288 % part_size = 0 (512KB aequaliter dividi debet per part_size)

Postrema pars his conditionibus satisfacere non debet, dummodo eius magnitudo minus sit quam partium magnitudo.

Utraque pars debet habere numerum sequentem; file_partcum valore vndique ab 0 ad 2,999.

Postquam tabella partita est, modum servandi in calculonis eligere debes. Usus upload.saveBigFilePart si plenam magnitudinem tabella plus quam X MB ac upload.saveFilePart pro minoribus.
[…] Unus ex sequenti notitia errorum initus reddi potest:

FILE_PARTS_INVALID — Numerus partium invalidus. De valore non est inter 1..3000

Num quid hoc in schemate est? Estne hoc nescio quo pacto TL expressibile utens? Nec. Sed me excusandum, etiam avus Turbo Pascal rationes specificatas describere potuit iugis. Et aliud noverat, nunc notius enum - Typus constans ex enumeratione numerorum certorum valorum. In linguis similibus C - numerorum, notandum quod hucusque de speciebus tantum locuti sumus numero. Sed etiam sunt vestes, chordae... exempli gratia, pulchrum esset describere hanc chordam tantum numerum telephonicum continere posse, rectum?

Nihil horum in TL. Sed est, exempli gratia, in Schema JSON. Et si aliquis alius de divisione 512 KB disputare posset, hoc adhuc in codice cohiberi necesse est, fac simpliciter clientem. Non potui plures feriunt 1..3000 (et error respondentis oriri non potuit) fieri potuisset, iure...

Viam circa errores et notas referre. Etiam qui cum TL labris operati sunt - non statim nobis illuxit unusquisque functio in TL revera reverti potest non solum genus reditus descriptas, sed etiam errorem. Sed hoc nullo modo deduci potest utendo ipso TL. Utique iam patet et nihil opus est in praxi (quamvis diversimode RPC fieri possit, ad hoc postea revertemur) — sed quid de puritate conceptuum Mathematicarum Abstractorum Genera. e coelesti mundo?

Denique quid de facilitate? Bene, ibi, generatim vellem Description ius habent in schemate (in JSON schema, iterum est), sed si iam cum eo coacta es, quid de parte practica - saltem trivialiter inspectiones diffs in updates? Vide te at vera exempla:

-channelFull#76af5481 flags:# can_view_participants:flags.3?true can_set_username:flags.6?true can_set_stickers:flags.7?true hidden_prehistory:flags.10?true id:int about:string participants_count:flags.0?int admins_count:flags.1?int kicked_count:flags.2?int banned_count:flags.2?int read_inbox_max_id:int read_outbox_max_id:int unread_count:int chat_photo:Photo notify_settings:PeerNotifySettings exported_invite:ExportedChatInvite bot_info:Vector<BotInfo> migrated_from_chat_id:flags.4?int migrated_from_max_id:flags.4?int pinned_msg_id:flags.5?int stickerset:flags.8?StickerSet available_min_id:flags.9?int = ChatFull;
+channelFull#1c87a71a flags:# can_view_participants:flags.3?true can_set_username:flags.6?true can_set_stickers:flags.7?true hidden_prehistory:flags.10?true can_view_stats:flags.12?true id:int about:string participants_count:flags.0?int admins_count:flags.1?int kicked_count:flags.2?int banned_count:flags.2?int online_count:flags.13?int read_inbox_max_id:int read_outbox_max_id:int unread_count:int chat_photo:Photo notify_settings:PeerNotifySettings exported_invite:ExportedChatInvite bot_info:Vector<BotInfo> migrated_from_chat_id:flags.4?int migrated_from_max_id:flags.4?int pinned_msg_id:flags.5?int stickerset:flags.8?StickerSet available_min_id:flags.9?int = ChatFull;

aut

-message#44f9b43d flags:# out:flags.1?true mentioned:flags.4?true media_unread:flags.5?true silent:flags.13?true post:flags.14?true id:int from_id:flags.8?int to_id:Peer fwd_from:flags.2?MessageFwdHeader via_bot_id:flags.11?int reply_to_msg_id:flags.3?int date:int message:string media:flags.9?MessageMedia reply_markup:flags.6?ReplyMarkup entities:flags.7?Vector<MessageEntity> views:flags.10?int edit_date:flags.15?int post_author:flags.16?string grouped_id:flags.17?long = Message;
+message#44f9b43d flags:# out:flags.1?true mentioned:flags.4?true media_unread:flags.5?true silent:flags.13?true post:flags.14?true from_scheduled:flags.18?true id:int from_id:flags.8?int to_id:Peer fwd_from:flags.2?MessageFwdHeader via_bot_id:flags.11?int reply_to_msg_id:flags.3?int date:int message:string media:flags.9?MessageMedia reply_markup:flags.6?ReplyMarkup entities:flags.7?Vector<MessageEntity> views:flags.10?int edit_date:flags.15?int post_author:flags.16?string grouped_id:flags.17?long = Message;

Ex omnibus dependet, sed GitHub, exempli gratia, in tanta linearum longarum mutationibus efferre recusat. Ludum "invenire X differentias", et quod statim cerebrum videt, idem est principium et fines in utroque exemplo, necesse est alicubi in medio legere prolixe... Opinor, hoc non est in theoria, sed solum uisum sordida et imperito.

Viam de theoria puritate. Cur agemus agros? Non videtur quod odor mali ex parte ratio? Explicatio videri potest in versionibus anterioribus schematis. Primo, sic, sic est, in omni sternumenta novum genus creatum est. Rudimenta haec adhuc in hac forma exstant, exempli gratia:

storage.fileUnknown#aa963b05 = storage.FileType;
storage.filePartial#40bc6f52 = storage.FileType;
storage.fileJpeg#7efe0e = storage.FileType;
storage.fileGif#cae1aadf = storage.FileType;
storage.filePng#a4f63c0 = storage.FileType;
storage.filePdf#ae1e508d = storage.FileType;
storage.fileMp3#528a0677 = storage.FileType;
storage.fileMov#4b09ebbc = storage.FileType;
storage.fileMp4#b3cea0e4 = storage.FileType;
storage.fileWebp#1081464c = storage.FileType;

Nunc autem finge, si agros ad libitum 5 habebis in structura tua, tunc 32 typi omnibus bene possibilibus indigebis. explosio composita. Sic puritas crystalli TL theoriae contra asinum missum ferreum acerbitatis serializationis iterum concussum est.

Praeterea nonnulli in locis ipsi latinae suam typologiam violant. Exempli gratia, in MTProto (capite sequenti) responsio a Gzip comprimi potest, omnia denique sunt - praeterquam quod laminis et ambitus violantur. Iterum, RpcResult non fuit ipsa messa, sed contenta. Bene, quid hoc?

Vel in alio exemplo, semel errorem invenimus - missus est InputPeerUser pro InputUser. Vel contra. Sed laboravi! Id est, server non curabat typum. Quomodo hoc? Responsio nobis detur per fragmenta codicis e telegraphi-cli;

  if (tgl_get_peer_type (E->id) != TGL_PEER_CHANNEL || (C && (C->flags & TGLCHF_MEGAGROUP))) {
    out_int (CODE_messages_get_history);
    out_peer_id (TLS, E->id);
  } else {    
    out_int (CODE_channels_get_important_history);

    out_int (CODE_input_channel);
    out_int (tgl_get_peer_id (E->id));
    out_long (E->id.access_hash);
  }
  out_int (E->max_id);
  out_int (E->offset);
  out_int (E->limit);
  out_int (0);
  out_int (0);

Aliis verbis, hoc est ubi fit serialization Manually, codice non genita! Fortasse ministra simili modo impletur? Hoccine est cur inventa ratio? Et hic proceditur ad alteram quaestionem.

Versione. Stratis

Quare versiones schismaticae dicuntur stratae nonnisi speculari possunt ex historia schismaticorum editorum. Primum, ut videtur, auctores rati res fundamentales fieri posse utentes immutato schemate, et solum si necessaria, propter postulationes specificas, indicare se in alia versione fieri. Principio, etiam utilem - et nova quasi "mixta", super veterem iacuit. Sed quomodo factum sit videamus. Verum, a primordio intueri non potui - iocularis est, sed schema de basi strato simpliciter non est. Strati inceperunt 2. Documenta nobis narrat de speciali TL pluma:

Si cliens fulcit Iacuit 2, tum sequens constructor utendum est:
invokeWithLayer2#289dd1f6 {X:Type} query:!X = X;
Re, hoc significat quod ante quamlibet API vocant, int cum valore 0x289dd1f6 addenda ante modum numeri.

Sonat tation. Sed quid deinde? Tunc apparuit

invokeWithLayer3#b7475268 query:!X = X;

Quid igitur postea? Ut coniicere possis;

invokeWithLayer4#dea0d430 query:!X = X;

Ridiculam? Imo nimis mane ad risum est, de eo cogita quisque postulatio ab alio strato tali specie speciali involvi debet - si omnia tibi diversa sunt, quomodo ea distinguere potes? Et addit mox 4 bytes in fronte satis efficax modus. Ita,

invokeWithLayer5#417a57ae query:!X = X;

Manifestum est autem quod post tempus aliquod bacchanalia fiet. Et venit solutio;

Renovatio: Satus cum Stratum IX, adiutor modi invokeWithLayerN non possunt nisi una cum initConnection

euge! Post 9 versiones, tandem venimus ad ea quae in interreti protocolla relata sunt in 80s - consentientes in versione semel in principio nexus!

Quid ergo est?...

invokeWithLayer10#39620c41 query:!X = X;
...
invokeWithLayer18#1c900537 query:!X = X;

Sed nunc adhuc rideo. Tantum post alia 9 stratis, constructor universalis cum numero versionis tandem additus est, qui semel tantum in principio nexus vocandus est, et significatio laminis evanuisse videbatur, nunc tantum est versio conditionalis, sicuti. passim alibi. Problema solverant.

Etiam?..

Vasily, [16.07.18 14:01] Etiam die Veneris cogitavi:
Teleservor res sine rogatu mittit. Petitiones in InvokeWithLayer involvi debent. Servus non involvit updates, nulla compages involvit responsa ac updates.

Illae. the client non potest specificare lavacrum in quo vult updates

Vadim Goncharov, [16.07.18 14:02] nonne fusum in principio invocat?

Vasily, [16.07.18 14:02]

Vadim Goncharov, [16.07.18 14:02] quod essentialiter significare debet cum lavacro in initio sessionis.

Viam sequitur, clientem downgradum non praeberi

Renovationes : i.e. type Updates in consilio, hoc est quod minister ad clientem mittit non petitioni API respondens, sed independenter cum eventu evenit. Hoc complexus est locus de quo in alio poste agetur, sed nunc interest scire quod server Updates salvet etiam cum client offline est.

Ita, si involvere nolueris quisque sarcina ad indicandam versionem suam, hoc logice ducit ad quaestiones possibiles sequentes;

server updates to the client mittit etiam ante clientem certiorem fecit quam versionem sustinet
quid faciam post upgrading clientem?
qui pollicerisententiam servi de numero lavacro in processu non mutare?

Putasne hoc esse speculationem mere theoricam, et in praxi hoc fieri non potest, quia servo recte scriptus est (saltem bene probatus est)? Ha! Utcumque est!

Id ipsum in Augusto incurrimus. Die 14 mensis Augusti fuerunt nuntii aliquid renovatum esse in servientibus Telegram ... et deinde in actis:

2019-08-15 09:28:35.880640 MSK warn  main: ANON:87: unknown object type: 0x80d182d1 at TL/Object.pm line 213.
2019-08-15 09:28:35.751899 MSK warn  main: ANON:87: unknown object type: 0xb5223b0f at TL/Object.pm line 213.

deinde plura megabyta e actis actis (bene, simul colligatio fixa). Ceterum, si aliquid in tuo TL non agnoscitur, subscriptio binarii est, linea ulterior OMNIS accedit, decoding fiet impossibilis. Quid facias in tali re?

Primum, quod ad mentem alicujus venit, est disiungendi et iterum conari. NON PROFUIT. Nos google CRC32 - haec objecta esse ex ratione 73, quamquam in 82 laboravimus. Inspicimus ligna - identificatores sunt ex duobus diversis technis!

Forsitan quaestio pure in clientelam nostram privatam venit? Imo telegram Desktop 1.2.17 deducimus (versio in multis distributionibus Linux suppleta), ad logum Exceptionis scribit: MTP genus inopinatum id #b5223b0f legitur in MTPMessageMedia…

Google ostendit problema simile iam uni ex clientibus priyatis factum esse, sed tum numeros versionis ac proinde suppositiones diversae...

Quid igitur faciamus? Vasily et discidium: conatus est renovare ambitum 91, decrevi paucos dies expectare et experiri in 73. Utraque methoda laboravit, sed quia empirica sunt, non est intellectus quot versiones sursum vel deorsum tibi necessariae sunt. ut salire, vel quam diu exspectare debes.

Postea condicionem effingere potui: clientem deducimus, averte, ambitum alii iacuit, sileo, problema rursus capio, ad priorem - Colloquia reverte, nulla copia circuitionis mutandi et clientis sileos pro pauci minutes adiuvabunt. Misce, ex diversis stratis structurarum notitiarum accipies.

Explicatio? Cum ex variis indirectis symptomatis conicere potes, minister constat ex pluribus processibus diversorum generum in diversis machinis. Verisimile, ministri qui responsalem "bufferandi" in queue imposuerunt quod sui superiores dederunt, et id dederunt in ratione quae in tempore generationis loco erat. Et donec haec queue "putris", nihil de eo fieri potuit.

Forsitan... sed hoc est atrox fusum?!.. Non, antequam de insanis ideis cogitamus, inspiciamus codicem clientium officialium. In versione Android non invenimus aliquem TL parser, sed invenimus fasciculum heftingum (GitHub noluerit eam tangere) cum serializatione. Hic sunt excerpta codicis:

public static class TL_message_layer68 extends TL_message {
    public static int constructor = 0xc09be45f;
//...
//еще пачка подобных
//...
    public static class TL_message_layer47 extends TL_message {
        public static int constructor = 0xc992e15c;
        public static Message TLdeserialize(AbstractSerializedData stream, int constructor, boolean exception) {
            Message result = null;
            switch (constructor) {
                case 0x1d86f70e:
                    result = new TL_messageService_old2();
                    break;
                case 0xa7ab1991:
                    result = new TL_message_old3();
                    break;
                case 0xc3060325:
                    result = new TL_message_old4();
                    break;
                case 0x555555fa:
                    result = new TL_message_secret();
                    break;
                case 0x555555f9:
                    result = new TL_message_secret_layer72();
                    break;
                case 0x90dddc11:
                    result = new TL_message_layer72();
                    break;
                case 0xc09be45f:
                    result = new TL_message_layer68();
                    break;
                case 0xc992e15c:
                    result = new TL_message_layer47();
                    break;
                case 0x5ba66c13:
                    result = new TL_message_old7();
                    break;
                case 0xc06b9607:
                    result = new TL_messageService_layer48();
                    break;
                case 0x83e5de54:
                    result = new TL_messageEmpty();
                    break;
                case 0x2bebfa86:
                    result = new TL_message_old6();
                    break;
                case 0x44f9b43d:
                    result = new TL_message_layer104();
                    break;
                case 0x1c9b1027:
                    result = new TL_message_layer104_2();
                    break;
                case 0xa367e716:
                    result = new TL_messageForwarded_old2(); //custom
                    break;
                case 0x5f46804:
                    result = new TL_messageForwarded_old(); //custom
                    break;
                case 0x567699b3:
                    result = new TL_message_old2(); //custom
                    break;
                case 0x9f8d60bb:
                    result = new TL_messageService_old(); //custom
                    break;
                case 0x22eb6aba:
                    result = new TL_message_old(); //custom
                    break;
                case 0x555555F8:
                    result = new TL_message_secret_old(); //custom
                    break;
                case 0x9789dac4:
                    result = new TL_message_layer104_3();
                    break;

aut

    boolean fixCaption = !TextUtils.isEmpty(message) &&
    (media instanceof TLRPC.TL_messageMediaPhoto_old ||
     media instanceof TLRPC.TL_messageMediaPhoto_layer68 ||
     media instanceof TLRPC.TL_messageMediaPhoto_layer74 ||
     media instanceof TLRPC.TL_messageMediaDocument_old ||
     media instanceof TLRPC.TL_messageMediaDocument_layer68 ||
     media instanceof TLRPC.TL_messageMediaDocument_layer74)
    && message.startsWith("-1");

Hmm... feram spectat. Sed, forsit, hoc generatur codice, tunc bene?.. Sed certe omnes versiones sustinet! Verum, non liquet cur omnia misceantur, colloquia secreta et omnia genera _old7 nescio quomodo generationi machinae similis non est.. Sed maxime me explodit

TL_message_layer104
TL_message_layer104_2
TL_message_layer104_3

Guys, ne quidem decernere potes quid intus iacuit? Bene, bene, dicamus "duo" errore dimissi sunt, bene fit, sed tres? Quale pornographia est hoc, doleo?

In fonte codice Telegram Desktop obiter accidit simile - si ita, plures in ordine ad schema committit non numerum lavacrum mutat, sed aliquid figat. In condicionibus, ubi nullus est fons officialis notitiae pro schemate, ubi obtineri potest, excepto fonte principii clientis officialis? Et si inde accipias, non potes certo certius rationem esse perfecte rectam donec omnes modos probes.

Quomodo etiam hoc probetur? Spero fans unitatis, functionis et aliorum probationum in commentarios communicabit.

Bene, inspiciamus aliam partem codicis:

public static class TL_folders_deleteFolder extends TLObject {
    public static int constructor = 0x1c295881;

    public int folder_id;

    public TLObject deserializeResponse(AbstractSerializedData stream, int constructor, boolean exception) {
        return Updates.TLdeserialize(stream, constructor, exception);
    }

    public void serializeToStream(AbstractSerializedData stream) {
        stream.writeInt32(constructor);
        stream.writeInt32(folder_id);
    }
}

//manually created

//RichText start
public static abstract class RichText extends TLObject {
    public String url;
    public long webpage_id;
    public String email;
    public ArrayList<RichText> texts = new ArrayList<>();
    public RichText parentRichText;

    public static RichText TLdeserialize(AbstractSerializedData stream, int constructor, boolean exception) {
        RichText result = null;
        switch (constructor) {
            case 0x1ccb966a:
                result = new TL_textPhone();
                break;
            case 0xc7fb5e01:
                result = new TL_textSuperscript();
                break;

Hoc commentarium "manualiter creatum" insinuat solam partem huius fasciculi manually scriptam esse (potesne existimas totum somnum exterreri?), cetera machinae generatae esse. Sed tunc alia quaestio oritur - fontes praesto sunt non omnino (a la GPL Blobs in Linux nucleo), sed iam est thema secundae partis.

Sed haec hactenus. Transeamus ad protocollum super quo haec omnia serialization currit.

MT Proto

Aperiamus igitur communia и ENARRATIO protocol ac primum offendimus dictio. Et rerum omnium copia. In genere, haec proprietas telegraphi videtur esse - res aliter in diversis locis, vel alia verbo uno vel vice versa (exempli gratia, in summo gradu API, si videris obice, non est. quod cogitasti).

Exempli causa, "nuntius" et "sessionis" aliquid hic aliud significant quam in consuetudine clientis Telegram. Bene omnia clare cum nuntio, in verbis OOP interpretari potuerunt, vel simpliciter verbum "fasciculum" appellatum - hoc est humili gradu onerariis, non sunt eadem nuntia ac in interface, multae sunt nuntii muneris . Sessio autem prima... prima.

onerariis lavacrum

Primum est oneraria nave exceptus. Dicent nobis de 5 optiones:

TCP
Websocket
Websocket in HTTPS
HTTP
HTTPS

Vasily, [15.06.18 15:04] Est etiam UDP transport, sed non documentum

Et TCP in tribus variantibus

Prima similis est UDP super TCP, quaelibet fasciculus includit ordinem numerum et crc .
Cur documenta in plaustro tam molesta legit?

Bene, ibi nunc est TCP iam in IV variantes:

adbreviata
medium
Padded medium
Full

Bene, ok, padded medium pro MTProxy, hoc postea additum est propter notas eventus. Sed cur duae plures versiones (tres omnino) cum uno obtinere potuisti? Omnes quattuor essentialiter differunt solum quomodo ad longitudinem et payload principali MTProto ponendam, de quo ulterius dicetur;

in abbreviatione est 1 vel 4 bytes, sed non 0xef, ergo corpus
in medio hoc est 4 bytes longitudinis et agri, et primum cliens mittere debet 0xeeeeeeee ut indicant est medium
in plena addictive, ex parte retis: longitudinis, seriei numeri, & NON ILLE qui maxime MTProto, corpus, CRC32. Haec omnia super TCP. Quae certa oneraria nobis praebet in modum sequentiae byte amnis, nullae sequentiae opus sunt, praesertim checks. Bene, nunc obiciet aliquis mihi quod TCP habet checksum 16-bit, sic notitia corruptionis accidit. Magna, sed nos actu protocollum cryptographicum habemus cum 16 bytes longius quam 32 bytes, omnes hi errores — magis etiam — a SHA mismatch in altiori gradu capientur. CRCXNUMX in hac parte nihil est.

Conferamus Abridged, in quo unus byte longitudinis possibilis est, cum Intermedia, qui iustificat "In casu 4-byte notitia noctis necessaria est", quod prorsus nugae est. Quid, creditur programmatores Telegram tam incompetentes esse ut notitias e nervum in quiddam aligned legere non possint? Adhuc hoc facere debes, quia lectio tibi numerum reddere potest (et sunt etiam procuratores, exempli gratia...). Vel contra, cur impedimentum abbreviatum si habebimus hefty Nullam super 16 bytes - save 3 bytes numquam ?

Improvisio fit quod Nikolai Durov reinventi rotas vere vult, protocolla retis inclusa, sine ullo reali necessitate practico.

Aliae optiones onerariae, incl. Web et MTProxy nunc non consideramus, fortasse in alio poste, si petitio est. De hoc eodem MTProxy nunc tantum meminerimus nos paulo post eius dimissionem anno MMXVIII, suggero celeriter didicisse, quod obiecit, destinatum. bypass interclusioin sarcina magnitudine! Et etiam quod servo MTProxy scriptum (iterum a Waltman) in C nimis ligatum erat specialibus Linux, quamvis hoc omnino non requiratur (probabit Phil Kulin), et similem servitorem vel in Go vel Node.js voluisset. convenire minus centum lineis.

Sed conclusiones de literatis technicis horum hominum in fine sectionis, consideratis aliis quaestionibus, concludemus. Nunc enim ad iacum V OSI transeamus, sessionem - in qua sessionem MTProto collocaverunt.

Claves, nuntii, sessiones, Diffie-Hellman

Ibi non omnino recte posuerunt... Sessio non est eadem sessionis quae in interface sub activarum sessionibus visibilis est. Sed ut.

Accepimus igitur filo byte notae longitudinis ab strato onerariis. Hoc est vel nuntius encryptus vel perplexus - si adhuc in scaena clavis pacti sumus et actu id facimus. Quem fasciculum notionum "clavis" loquimur? Hanc quaestionem pro ipso team telegram declarabimus (me paenitet me de litteris propriis Anglicis cum fesso cerebro 4 am transferre; facilius erat nonnullas locutiones relinquere sicut sunt);

Sunt duo dicta sessionem - una in UI clientium officialium sub "sessionibus currentibus", ubi singulae sessiones integrae fabricae respondet / OS.
secundus - MTProto sessionqui habet ordinem numerorum relatum (in sensu humili gradu) in eo, et quem diversis TCP iungebat durare. Plures MTProto sessiones simul institui possunt, exempli gratia, ut lima downloading acceleraretur.

Inter haec duo sessions conceptus est auctoritas. In pravo casu possumus dicere III session idem quod auctoritassed heu perplexa omnia. Intueamur:

A user in nova fabrica primo generat auth_key et terminat ad rationem, exempli gratia per SMS - id est quare auctoritas

Accidit intra primum MTProto sessionquae habet session_id intra te ipsum.

Hic gradus, coniunctio auctoritas и session_id posse vocari exempli gratia - Hoc verbum in documentis et codice nonnullorum clientium apparet

Tum, clientis aperire potest aliquot MTProto sessiones sub eodem auth_key — Ad eundem AC.

Tum, quadam die cliens tabellam ab eo postulare debebit alterum DC * et pro hoc dc nova generabitur auth_key !

Rationem docere non esse novum usorem qui perscriptum est, sed idem auctoritas (III session) Cliens utitur API vocat auth.exportAuthorization in domo DC * auth.importAuthorization in nouis AC.

Omnia idem sunt, plura patent MTProto sessiones (Quisque cum suis session_id) huic dc novo, sub eius auth_key.

Demum, cliens velit Perfect Forward Secrecy. Omne auth_key erat permanens clavem per DC et clientem potest vocare auth.bindTempAuthKey ad usum tempus auth_key - et iterum tantum temp_auth_key per DC, communis omnibus MTProto sessiones ad hunc DO.

nota quod salis (Salia et futura) est etiam unum auth_key illae. participatur inter omnes MTProto sessiones ad eundem AC.

Quid est "inter coniunctiones diversas TCP"? Hoc est ergo aliquid simile auctoritas crustulum in loco posito - manet (superest) multos hospites TCP servo dato, sed uno die corruptus est. Tantum dissimiles HTTP, in MTProto nuntii intra sessionem continue numerantur et confirmantur, si cuniculum intrant, nexus ruptus est - post novam connexionem constituendam, minister benigne omnia in hac sessione mittet quae in priore non liberavit. TCP xxxvi.

Attamen indicium superius post multos menses inquisitionis digestus est. Interim hunc de integro clientem fovemus? — Ad initium eamus.

Sit scriptor generate auth_key on Diffie-Hellman versiones ex telegrapho. Conemur intelligere documenta ...

Vasily, [19.06.18 20:05] data_with_hash := SHA1(data) + data + ut longitudinis 255 bytes aequalis;
encrypted_data := RSA(data_with_hash, server_public_key); a 255-byte longus numerus elevatur ad debitam potestatem super modulum requisitum, et effectus reponitur sicut numerus 256-byte.

Quidam habent dope DH

Non tamquam sanus homo est DH
Nullae duae claves publicae in dx sunt

In fine hoc digestum est, sed residuum remansit - probatio operis fit per clientem quod numerus factor potest. Genus praesidii contra impetus DoS. Clavis autem RSA semel tantum in una parte adhibetur, essentialiter pro encryption new_nonce. Sed dum haec operatio, quae videtur, simplex succedit, quid habebis ad faciem?

Vasily, [20.06.18/00/26 XNUMX:XNUMX] Petitioni tamen non quaesivi

Rogavi DH

Et in navale onerario dicit respondere posse cum 4 bytes erroris codice. Id est omnia

Hem, dixit mihi —404, Quid ergo?

Et dixi ei: "Cape bullshit encryptatum cum servo clavem cum fingerprint sicut hoc, DH volo" et respondit stolide 404

Quid de hac servo responsionem arbitraris? Quid facere? Nemo est qui quaeret (sed magis in secunda parte).

Hic omnis cura aguntur in navale

Nihil aliud facere habeo, modo somniavi numerum convertendi ultro citroque

Duo numeri XXXII bis. Ego facis eos sicut ceteri

Sed haec duo lineae primae ut BE addenda non sunt

Vadim Goncharov [20.06.18 15:49] et ob id 404?

Vasily, [20.06.18 15:49] ETIAM!

Vadim Goncharov, [20.06.18 15:50] sic non intellego quid possit "non inveni".

Vasily, [20.06.18 15:50]. fere

Talem compositionem in primos factores invenire non potui%

Nos ne errorem quidem administrare

Vasily, [20.06.18 20:18] Oh, etiam est MD5. Iam tribus diversis hashes

Clavis fingerprints sic computatur:
digest = md5(key + iv)
fingerprint = substr(digest, 0, 4) XOR substr(digest, 4, 4)
SHA1 et sha2

Ita induamur auth_key 2048 frenos in magnitudine utentes Diffie-Hellman accepimus. Quid suus 'postero? Deinde reperimus inferiores 1024 huius clavis frenos nullo modo esse adhibitos ... sed nunc de hoc cogitamus. Ad hoc gradum secretum commune cum servo habemus. Analogium sessionis TLS constitutum est, quae ratio valde pretiosa est. Sed tamen nihil scit de servo qui sumus! Nondum etiam. auctoritas. Illae. si cogitaveris secundum "login-password", ut olim in ICQ, vel saltem "clavem login-", ut in SSH (exempli gratia, in aliquo gitlab/github). Venimus anonymum unum. Quid si ministrans nos monet "hos numeros telephonicos ab alio DC ministratos esse"? Aut etiam “interdictum est numerus telephonicus”? Optimum possumus facere clavem in spe, quod utile erit nec tunc putridum erit.

Obiter eam cum exceptionibus "accepimus". Puta speramus servo? Quid si fictus est? Compesculationes cryptographicae necessariae essent:

Vasily, [21.06.18 17:53] Clientes mobiles offerunt ad reprimendam numerum 2kbittarum pro primalitate%)

Sed omnino non liquet, nafeijoa

Vasily, [21.06.18 18:02] Documentum quid faciendum sit non dicit si simplex non sit.

Non dixit. Videamus quid clientis MASCULINUS officialis in hac causa agit? A Hoc illud est quod (et ita, totus fasciculus amet) - sicut aiunt, hic ego hanc relinquam:

278     static const char *goodPrime = "c71caeb9c6b1c9048e6c522f70f13f73980d40238e3e21c14934d037563d930f48198a0aa7c14058229493d22530f4dbfa336f6e0ac925139543aed44cce7c3720fd51f69458705ac68cd4fe6b6b13abdc9746512969328454f18faf8c595f642477fe96bb2a941d5bcd1d4ac8cc49880708fa9b378e3c4f3a9060bee67cf9a4a4a695811051907e162753b56b0f6b410dba74d8a84b2a14b3144e0ef1284754fd17ed950d5965b4b9dd46582db1178d169c6bc465b0d6ff9ca3928fef5b9ae4e418fc15e83ebea0f87fa9ff5eed70050ded2849f47bf959d956850ce929851f0d8115f635b105ee2e4e15d04b2454bf6f4fadf034b10403119cd8e3b92fcc5b";
279   if (!strcasecmp(prime, goodPrime)) {

Non, sane suus 'ibi' quidam Testimenta sunt plurium primalitatis, sed personaliter iam non habeo sufficientem mathematicam scientiam.

Bene, clavis magistrum obtinuit. Ad log in, i.e. petitiones mitto, encryption amplius praestare debes, adhibitis AES.

Mandatum clavem definitur esse 128 medias partes corporis nuntii SHA256 (inclusa sessione, nuntius ID, etc.), inclusa bytes Nullam, quae ab 32 bytes e clavis auctoritatis sumpta est.

Vasily, [22.06.18 14:08] Mediocris, bitch, freni

accepistis auth_key. Omnis. Extra eos... ex documento non liquet. Libenter studere in aperto fonte codice.

Nota MTProto 2.0 postulare ab 12 ad 1024 bytes colorum, sub condicione tamen ut nuntius consequens longitudo per 16 bytes dividatur.

Quantum ergo Nullam addere debes?

Et sic, etiam 404 in casu erroris est

Si quis diligenter investigavit tabulam et textum documentorum, animadverterunt MAC ibi esse. Atque AES quodam IGE modo adhibetur, qui alibi non utitur. Illi quidem de hoc scribunt in suis FAQ... Hic, sicut, nuntius ipsa clavis est etiam SHA decryptedarum notitiarum, integritatem reprimendam - et in casu mismatch, documentum aliqua de causa. tacite dissimulans commendat (sed quid de securitate, quid si frangant?).

Ego non sum cryptographus, fortasse nihil mali est in hac re ex theoretica ratione. Sed quaestionem practicam clare nominare possum, telegram Desktop utens exemplo. Cache locale (omnia haec D877F783D5D3EF8C) encryptas eodem modo ac nuntios in MTProto (tantum in casu versionis 1.0), i.e. primum nuntium clavem, deinde ipsa notitia (et alicubi omissis maximis magnis" auth_key 256 bytes, sine quo msg_key inutilia). Quaestio igitur in magnis patulis conspicitur. Nempe duo exemplaria notarum encrypted et decryptas servare debes. Et si sunt megabytae, vel video effusis, exempli gratia? Sed cum MTProto habebis to primus encrypt vel minutum totum nuntium, tum demum ad retiaculum vel ad disci transfer. Itaque in recentissimis versionibus Telegrammi Desktop in cella in user_data Alia forma adhibetur etiam - cum AES in CTR modo.

Vasily, [21.06.18 01:27] Oh, inveni quid IGE est: IGE primus conatus "encryptionis authenticitatis" primitus pro Kerberos. Incassum conatus (non enim integritatis tutelam praebet), et ab exilio removeri oportuit. Hoc initium erat 20 anni quaerendi modum encryptionis authenticae operantis, quae nuper in modis OCB et GCM terminatur.

Jamque argumenta a plaustri parte;

Manipulus post Telegram, Nikolai Durov ductus, sex pugiles ACM, dimidium Ph.Ds in math. Eos duos circiter annos cepit ut e emendatione MTProto evolvatur.

Ut iocularis. Duobus annis in inferiore gradu

Aut tu iustus accipere tls

Bene, encryptiones et alias nuances te fecisse dicamus. Num tandem fieri potest ut petitiones TL serialized in TL et responsiones deseriales mittere possit? Quid ergo et quomodo mittes? Hic, inquam, modum initConnectionfortasse hoc est?

Vasily, [25.06.18 18:46] Connexionem initializet et informationes in utentis artificio et applicatione conservat.

Accipit app_id, device_model, system_versionem, app_versionem ac lang_code.

Et nonnulla quæstio

Documenta ut semper. Libenter studere aperto fonte

Si omnia proxime clara erant cum invocatione WithLayer, quid hic mali est? Evenit, dicamus nos habere - clientem iam habui aliquid quod servo de eo peteret - est petitio quam mittere vellemus;

Vasily, [25.06.18 19:13] Ex codice iudicans, prima vocatio in hoc luto involvitur, et lutum ipsum in advocationibus involvitur.

Cur initConnection non potuit esse vocatio separata, sed fascia esse debet? Ita, ut evenit, omni tempore in principio cuiusque sessionis fieri debet et non semel, sicut cum principali clavi. Sed! Non potest dici ab usore alieno! Nunc eo spectaculo perventum est ubi convenit Hoc unum documenta pagina - ac nos docet.

Tantum parva API methodi portio in legitimis usoribus praesto sunt:

auth.sendCode
auth.resendCode
account.getPassword
auth.checkPassword
auth.checkPhone
auth.signUp
auth.signIn
auth.importAuthorization
help.getConfig
help.getNearestDc
help.getAppUpdate
help.getCdnConfig
langpack.getLangPack
langpack.getStrings
langpack.getDifference
langpack.getLanguages
langpack.getLanguage

Prima ipsa, auth.sendCodeet est illa prima petitio fovenda in qua api_id et api_hash mittimus, et post quod cum codice SMS accipimus. Et si in culpa DC sumus (telephonis numeri in hac regione ab alio serviuntur, exempli gratia), errorem recipiemus cum desiderati DC numero. Ut invenias quem IP oratio per DC numerum coniungere debes, adiuva nos help.getConfig. Vno modo erant solum V viscus, sed post claros eventus MMXVIII, numerus signanter crevit.

Nunc meminerimus nos huc venisse ab auctore incerti auctoris. Nonne nimis pretiosa est ut IP oratio usurpet? Cur non hoc, et aliae operationes in unencrypta parte MTProto? Obiectionem audio: "Quomodo efficere possumus qui falsis allocutionibus respondeat non esse RKN?" Ad hoc meminimus in genere clientium officialium RSA claves embedded, i.e. tu iustus subscribe hoc nuntio. Profecto hoc iam factum est pro informatione de interclusione interclusione clientium per alios canales recipiunt (logice, hoc in ipso MTProto fieri non potest; etiam scire debes ubi coniungere).

OK. Hac in scaena auctoritatis clientelae nondum auctoritates sumus nec applicationem nostram descripserunt. Modo videre volumus nunc quid ministrans respondeat rationibus usori non legitimo praesto. Et hic…

Vasily, [10.07.18 14:45]. https://core.telegram.org/method/help.getConfig
config#7dae33e0 [...] = Config;
help.getConfig#c4f9186b = Config;
https://core.telegram.org/api/datacenter
config#232d5905 [...] = Config;
help.getConfig#c4f9186b = Config;
In schemate, primus secundus

In schemate tdesktop tertium valorem

Quia tunc, utique, documentum renovatum est. Tametsi mox iterum inutile fiet. Quomodo elit novitius scire debet? Forsitan si applicationem tuam subcriptio, docebunt te? Vasly hoc fecit, sed heu, illi nihil (iterum loquemur in altera parte).

... Animadvertisti nos iam aliquo modo ad API, i.e. ad gradum gradum, et aliquid desiderari in MTProto argumento? Minime mirum;

Vasily, [28.06.18 02:04] Mm, per algorithms in e2e rimantur.

Mtproto encryption algorithmorum et clavium tam ditiones definitas quam aliquantulum structurae involucri

Sed constanter diversos gradus acervi miscent, unde non semper liquet ubi mtproto finitur et gradum proximum coepit

Quomodo miscent? Bene, hic clavis temporalis pro PFS, exempli gratia (per Desktop Telegram hoc facere non potest). Fit ab API petitionem auth.bindTempAuthKey, i.e. a summo gradu. Simul autem impedit encryption in inferiore gradu - post eam, verbi gratia, iterum facere debes. initConnection hoc non est etc tantum rogatu normali. Illud quoque speciale est quod unam tantum clavem temporalem per DC habere potes, quamvis campum auth_key_id in unoquoque nuntio permittit tibi clavem mutare saltem singula verba, et servo ius habet "oblivisci" clavem temporalem aliquando - documentum non dicit quid in hac causa facere... bene, cur posset. 't habes plures claves, ut cum copia futurorum salium, et ?.

Pauca alia de MTProto themate notatu digna sunt.

Mandata mandata, msg_id, msg_seqno, confirmationes, pings in directione mali et aliae idiosyncrasies

Quid opus est scire? Quia "leak" ad altiorem gradum, et necesse est ut earum conscius sit cum operando cum API. Sumamus nos in msg_key non quaero, inferiore gradu omnia nobis decrypta sunt. Sed intra decrypted notitias sequentes agros habemus (etiam longitudo notitiarum, ut novimus ubi color est, sed non magni momenti):

sal - int64
session_id - int64
message_id - int64
seq_no - int32

Monemus te unum tantum esse salis pro toto DO. Quid novi? Non solum quia petitio est get_future_saltsquod tibi narrat quae intervalla valida erunt, sed etiam quia si sal tuum est "putri", nuntius simpliciter amittetur. Servus utique novum salem nuntiabit editis new_session_created - sed cum veteri habebis rescindere aliquo modo, ut puta. Atque haec quaestio pertinet ad applicationem architecturae.

Ministro licet sessiones omnino decidere et hoc modo multis de causis respondere. Actu, quid est MTProto sessionis ex parte clientis? Hi numeri duo sunt session_id и seq_no nuntii in hac sessione. Bene, et subest TCP nexus, scilicet. Dicamus clientem nostrum adhuc multa facere nesciat, disiunctus et reconnectus. Si hoc cito factum est - vetus Sessio continua in nova TCP connexione, crescat seq_no porro. Si longum tempus accipit, server potest eam delere, quia in eius parte etiam queue est, sicut invenimus.

Quid sit? seq_no? Oh, id est quaestio captiosa. Conare honeste intelligere quid esset;

Contentus ex actis Nuntius

Epistulam agnitionem explicitam requirit. Haec omnia utentis et multae nuntiis inserviunt, omnes fere excepto vasis et agnitionibus.

Sequentia Nuntius Number (msg_seqno)

Numerus 32-frenus aequalis duplo numerus nuntii "content-relato" (quae agnitionem requirunt, et praesertim eas quae continentia non sunt) a mittente ante hoc nuntium creatum et postea ab uno incremento si nuntius hodiernus est. contentus actis nuntius. Continens semper generatur secundum totum suum contenta; ergo eius ordo maior est quam vel aequalis numerorum sequentium nuntiorum in eo contentorum.

Quod genus circi hoc est cum incremento per 1, et deinde alterum per 2?.. Suspicor initio "minimum significare camum pro ACK, reliqua numerus", sed eventus non satis idem est. specialiter exeat, mitti possit aliquot confirmationes habent idem seq_no! Quam? Bene, exempli gratia, server aliquid nobis mittit, illud mittit, et nos ipsi tacemus, tantum respondemus cum servitio nuntiis confirmandis nuntiis acceptis. In hoc casu, exitus confirmationes nostrae eundem numerum habebunt. Si nota est cum TCP et cogitari hoc sonat quodammodo feram, sed non valde feram videtur, quia in TCP seq_no non mutatur, sed confirmatio pergit seq_no ego illinc properabo te perturbare. Confirmationes provisum est in MTProto nON on seq_nout in TCP, sed per msg_id !

Quid est hoc msg_idmaxime ex his agris? Singularis nuntius identifier, ut nomen sonat. Definitur numerus 64 frenum, cuius infimus lamellae iterum magicae "servo-non-server" habent, ceteraque nota est Unix, inclusa parte fracti, 32 minutas ad sinistram movit. Illae. indicatione per se (and epistulae cum temporibus multum differentibus a servo reicientur). Inde evenit ut universaliter identifier globalem clienti sit. Datum quod - meminimus session_id — praestamur; Nullo casu potest nuntius destinatus unius sessionis in aliam sessionem mitti. Id est, iam evenit tribus planities - session, session numerus, nuntius id. Quare talis overcomplication hoc mysterium valde magnum est.

Sic, msg_id opus est...

RPC petitiones, responsiones, errores. Confirmationes.

Ut animadvertistis, nullum est speciale "RPC petitionem" genus vel functionem usquam in schemate facere, quamvis responsa sint. Post omnes nuntios contentos habemus! Ille est, nihil perferre preces posset! Vel non esse. Ceterum quisque est msg_id. Sed responsa sunt:

rpc_result#f35c6d01 req_msg_id:long result:Object = RpcResult;

Id ubi indicatur cuius nuntius haec responsio est. In summo igitur gradu API, memorari debebis quid petitio tua fuerit numerus - nihil enim opus esse censeo asynchronum opus exponere, et plures simul in progressu petitiones esse possunt; ad quae responsa ordine reddi possunt? Principio, ab hac et errorum nuntiis sicut nullus opificum, architectura post haec investigari potest: cultor qui nexum cum TCP servat, librarius ante-finis est, petit ut tergum proveniat et per eos reducat. message_id. Videtur quod omnia hic sint manifesta, logice et bona.

Etiam?.. Et si cogitas? Ceterum responsio ipsa RPC agrum etiam habet msg_id! Non opus est nobis clamanti servo “Non respondes mihi?”? Et sic, quid erat de confirmationibus? De pagina nuntia de nuntiis narrat quid

msgs_ack#62d6b459 msg_ids:Vector long = MsgsAck;

et ab utroque latere debet. Sed non semper est! Si RpcResult accepit, ipsa confirmatio est. Hoc est, minister petitioni tuae respondere potest cum MsgsAck - sicut "Accepi eam." RpcResult statim respondere potest. Posset utrumque.

Et sic, adhuc respondere debes! Confirmatio. Alioquin servans eam inexplicabilem reputabit et iterum ad te mittet. Etiam post reconnect. Sed hic quidem temporum eventus oritur. Intueamur paulo post.

Interim inspiciamus quotquot errores inquisitionis exsecutionis.

rpc_error#2144ca19 error_code:int error_message:string = RpcError;

Oh, exclamabit aliquis, hic forma humanior est — versus est! Sume tibi tempus. Hic index errorumsed cursus integer. Ex eo discimus codicem esse aliquid simile Errores HTTP (bene, sane, quae responsiones semanticae non servantur, in quibusdam locis passim in codicibus distributa sunt), et versus similis est. CAPITAL_LETTERS_AND_NUMBERS. Exempli gratia, PHONE_NUMBER_OCCUPIED vel FILE_PART_Х_MISSING. Bene, id est, hac linea adhuc opus erit parse. Eg FLOOD_WAIT_3600 significabit te exspectare horam PHONE_MIGRATE_5, numerum telephonicum cum hac praepositione adscribi debere in 5th DC. Typum habemus lingua, vox? Argumento a filo non indigemus, regulares bene facient.

Iterum, hoc non est in pagina nuntiorum officiorum, sed, ut iam in usu est, indicium inveniri potest in alia documenta pagina. uel suspicionem. Uno modo, vide typing / iacuit contra - RpcError potest nidificari in RpcResult. Quidni foris? Quid non habuimus rationem? RpcError non potest haerere RpcResultsed in alio genere directe vel nidificari?... Et si non potest, cur non in summo gradu, i.e. id est absentis req_msg_id ? ..

Sed pergamus de nuntiis servitium. Cliens putet se diu cogitare posse et hoc mirabilem petitionem facere:

rpc_drop_answer#58e4a740 req_msg_id:long = RpcDropAnswer;

Tria huic quaestioni responsa possibilia sunt, iterum intersecantes cum mechanismo confirmationis, quaerentes quid debeant (et quid generalis index generum confirmationem non requirat) lectori relinquitur ut congue (nota: notitia in Telegraphum Desktop codice fonte non completum est).

Medicamento PROCLIVITAS: nuntius status

In genere multis locis in TL, MTProto et telegrapho in genere relinquunt obstinationis affectum, sed ex civilitate, ingenio, et aliis. mollis vitae Nos blande de hoc tacuimus, et in dialogis obscenitates notavimus. Sed hoc locoОmaxime paginae de nuntia de nuntiis Horrendum est etiam mihi, qui protocolla diu laboravit et birotas variarum perversorum graduum vidit.

Innocue incipit, cum confirmationibus. Deinde dicunt de nobis

bad_msg_notification#a7eff811 bad_msg_id:long bad_msg_seqno:int error_code:int = BadMsgNotification;
bad_server_salt#edab447b bad_msg_id:long bad_msg_seqno:int error_code:int new_server_salt:long = BadMsgNotification;

Bene, quisque qui laborat cum MTProto incipit agere cum illis debebit, in cyclo "correcto - compilato - immisso", numerus errorum vel salem questus, qui in emendationibus malam ire curaverit, commune est. Circa primum autem quaeruntur duo.

Hoc significat nuntium originale amissum est. Necesse est aliquas queues creare, quas postea spectabimus.
Quid sunt hi numeri error insolitus? 16, 17, 18, 19, 20, 32, 33, 34, 35, 48, 64. ... ubi sunt alii numeri, Tommy?

Documenta civitatum:

Intentio est quia valores error_code comprimuntur (error_code >> 4): exempli gratia, codices 0x40 — 0x4f respondent erroribus in compositione continente.

sed primo, mutationem in alteram partem, secundo refert, ubi sunt ceteri codices? In auctoris capite?.. Sed haec nugae sunt.

ADIECTIO nuntiis incipit de nuntiis de statuum ac relatum exemplaribus:

Petentibus Nuntius Status Information
Si alterutra pars informationem de statu sui temporis ad tempus non accepit, potest id expresse ab altera parte petere;
msgs_state_req#da69fb52 msg_ids:Vector long = MsgsStateReq;
Nuntius informational de Status Messages
msgs_state_info#04deb57d req_msg_id:long info:string = MsgsStateInfo;
Hic, info est filum, quod prorsus unum byte continet status nuntium ad nuntium e msg_ids advenientis album:
- 1 = nihil notum est de nuntio (msg_id preme, altera pars eam oblitam esse potest)
- 2 = nuntius non receptus (msg_id cadit intra teli reconditorum identificantium; attamen altera pars nuntium talem certe non accepit)
- 3 = nuntius non receptus (msg_id nimis altum est; attamen altera pars certe nondum eam accepit)
- 4 = nuntius acceptus (nota hanc responsionem etiam simul acceptilatio agnitionis);
- VIII = nuntius iam agnitus
- XVI = nuntius non eget agnitionem
- +32 = RPC Quaesitio continebat nuntium discursum vel dispensando iam completum
- LXIV = contentus relatas responsio ad nuntium iam generatae
- CXXVIII = altera pars scit pro eo quod nuntius iam accepit
  Haec responsio agnitionem non requirit. Agnitio tivis msgs_state_req, in se ac.
  Nota quod si repente evenit ut altera pars nuntium non habet quod simile ei missum est, nuntium simpliciter remitti potest. Etiamsi altera pars duo exemplaria nuntium simul reciperet, duplicatum ignorabitur. (Si nimium tempus praeteriit et originale msg_id iam non valet, nuntius in msg_copy involvendus est).
Communication voluntaria Status Messages
Utraque pars potest sponte alteram partem status nuntiorum ab altera parte transmissam certiorem facere.
msgs_all_info#8cc0d131 msg_ids:Vector long info:string = MsgsAllInfo
Voluntaria Communication Status of One Nuntius extensa
...
msg_detailed_info#276d3ec6 msg_id:long answer_msg_id:long bytes:int status:int = MsgDetailedInfo;
msg_new_detailed_info#809db6df answer_msg_id:long bytes:int status:int = MsgDetailedInfo;
Expresse Request ad Re-mitte abicere
msg_resend_req#7d861a08 msg_ids:Vector long = MsgResendReq;
Pars remota statim respondet nuntiis rogatas re-mittens […]
Expressa Request ad Re-mitte Answers
msg_resend_ans_req#8610baeb msg_ids:Vector long = MsgResendReq;
Pars remota statim respondet a re-mitto Answers nuntiis rogatus […]
Epistulae Copiae
In aliquibus adiunctis, nuntius vetus cum msg_id quod validum non est, necessitates re-missae sunt. deinde in vase exemplari involvitur;
msg_copy#e06046b2 orig_message:Message = MessageCopy;
Cum receptum est, nuntius discurrit quasi fasciculus ibi non sit. Attamen si notum est pro certo nuntium orig_message.msg_id receptum esse, nuntius novus non discessit (dum eodem tempore, is et orig_message.msg_id agnoscitur). Valor orig_message.msg_id debet esse inferior quam vas msg_id.

Let's vel taceas quid msgs_state_info iterum aures imperfecti TL exsertae (vector e bytes indigebat, et in inferioribus duobus frenis erat enum, et in superioribus duobus lamellis vexilla erant). Differt punctum. Num quis intelligit quare haec in usu sint? per verum clientis Necesse est? Hic autem petitiones describuntur per iter.

Sequitur ut quaelibet pars non solum epistulas encryptas et nuntios mittere debet, sed etiam notitias de seipsis, de responsionibus ad eas, temporis incertis moles. Documenta vel timiones vel applicabilitatem horum notarum non describit. nullo modo. Quid mirum est quod in codice clientium usi sunt! Apparenter aliquid nuntiaverunt quod in documentis publicis non continebatur. Intellige ex codice quod, non iam tam simplex quam in casu TL - non est pars logice separata, sed pars ligata ad applicationem architecturae, i.e. signanter tempus requiret ad intelligendum codicem applicationis.

Pings et timings. Queues.

Ex omnibus, si meminimus coniecturas de servo architecturae (distributione petitionum trans backends), res tristior sequitur - quamquam omnes cautiones traditionis in TCP (vel notitia liberata est, vel de hiatu certiores erunt, sed notitia tradetur antequam quaestio occurrat), confirmationes in ipso MTProto. nulla cautione. Servus nuntium tuum facile amittere vel emittere potest, et nihil de eo fieri potest, diversis speciebus fusum modo utere.

Ac primum omnium - nuntius queues. Bene, uno ab initio omnia apparebant - nuntius firmus condi debet ac dolere. Et post quod tempus? et scurra cognoscit eum. Forsitan operae addicti nuntii hanc quaestionem fustibus quodammodo solvunt, dicunt in Telegram Desktop circiter 4 queues illis correspondentes (fortasse plures, ut iam dictum est, hoc opus est in suum codicem et architecturam gravius incurrere, eodem modo. tempore, Scimus non posse sumi pro exemplo: aliquot typi e schemate MTProto in eo adhibiti non sunt.

Quid hoc est? Probabiliter programmatores ministrantes fidem intra botrum efficere potuerunt, vel etiam buffering in fronte librari, et hanc quaestionem in clientelam transtulerunt. De desperatione, Vasily optionem alternam efficere conatus est, duabus tantum queuis, utens algorithms ex TCP - metens RTT ministranti ac magnitudinem "fenestrae" (per nuntiis) aptans secundum numerum postulatorum confirmatarum. Hoc est, tam aspera heuristica in perpendendis oneris servientis quot petitiones nostrae possunt simul mandere et non amittere.

Id est, recte intellegis? Si denuo ad effectum deducendi TCP super protocollo super TCP superfluente, hoc indicat protocollum pessime designatum.

Oh yeah, cur plus quam unum queue opus est, et quid hoc significat hominem operantem cum summus gradus API usquam? En rogas, vide, sed saepe statim mittere non potes. Quare? Quia responsum erit msg_idquae est temporalisаEgo sum pittacium, cuius assignatio optime differtur usque dum quam proxime potest - si minister eam reiicit ob mismatch temporis inter nos et illum (scilicet fustem facere possumus quae tempus nostrum ab hodierno variat. servo addendo della computata e responsionibus servi - clientes officiales hoc faciunt, sed rudis et impropria est ob buffering). Cum igitur munus locale vocationi e bibliotheca petitur, nuntius sequentis gradus pertractat;

In una queue iacet et encryption manet.
constituit msg_id et nuntius ad alium queue - procuret; ad nervum mittere.
a) Servus respondit MsgsAck - traditum nuntium, eam delemus ex "alia queue".
b) Vel e converso, aliquid simile nolebat, badmsg - resend a "alia queue".
c) Nihil scitur, nuntium dolere debet ab alio queue — sed prorsus quando ignoratur.
Servo tandem respondit RpcResult - responsio ipsa (vel error) non modo liberata est, sed etiam processit.

maybeusus continentiae partim problema solvere posset. Haec cum fasciculus epistularum in unum refertus est, et minister cum confirmatione respondit omnibus statim in unum. msg_id. Sed hanc quoque sarcinam, si quid peccaverit, reiiciet in integrum.

Hic iam non-technicae considerationes oriuntur. Ab experientia multa fusum vidimus, et praeterea plura exempla malorum consiliorum et architecturae nunc videbimus - in his conditionibus, num fidele ac decernentibus dignum est? Quaeritur rhetorica (non utique).

Quid ergo dicemus? Si in themate "medicinae epistulae de nuntiis" adhuc obiectionibus speculari potes sicut "stulte es, nostrum egregie consilium non intellexisti!" (sic scribe documenta primum, ut normales homines debent, cum rationalibus et exemplis permutationis conlisi, deinde loquemur), tunc temporis momenta sunt quaestio mere practica et specifica, quae hic diu nota sunt. Quid nobis documenta narrant de timeouts?

Servus acceptionem nuntium ex cliente agnoscit (vulgo interrogatione RPC) responsionem RPC utens. Si responsio longum tempus veniat, cultor primum agnitionem acceptilationem mittere potest, et aliquanto post, RPC responsum ipsum.

Solet cliens acceptum nuntium agnoscit a servo (plerumque responsum RPC) agnitionem addendo RPC interrogationi proximae si sero non transmittitur (si generatur, dic 60-120 secundis post acceptum. nuntius a servo). Attamen, si per longum tempus nulla causa est, nuntios mittendi servo vel si numerus est incognitus a servo nuntia (dic, supra 16), cliens solam agnitionem stanti transmittit.

... transfero: ipsi nescimus quantum et quomodo opus sit, sic id sit quod sic ponamus.

Et de pings;

Ping Messages (PING/PONG)
ping#7abe77ec ping_id:long = Pong;
Solet autem responsio ad eundem nexum reverti;
pong#347773c5 msg_id:long ping_id:long = Pong;
Hae epistulae agnitiones non requirunt. Pong ad pingendum solum traducitur dum ping ab utraque parte initiari potest.

Dilata Connection conclusione + PING
ping_delay_disconnect#f3427b8c ping_id:long disconnect_delay:int = Pong;
Opera quasi ping. Praeterea, postquam hoc receptum est, server timer incipit quod nexum hodiernam disconnect_mora posteriora claudet, nisi novum eiusdem generis nuntium recipiat, qui omnes timers priora automatice reponit. Si cliens pinges has mittat semel singulas 60 secundis, exempli gratia, disconnect_dilationem potest 75 secundis aequalem ponere.

Esne insanis?! In secundis 60 stationem tramen intrabit, defluet et vectores colliget, et contactum in cuniculo iterum amittet. In secundis 120, dum audis, ad aliud perveniet, et nexus verisimiliter franget. Bene, patet ubi crura veniunt ex - "strepentem audivi, sed nescimus ubi sit", ibi algorithmus Nagl's et optio TCP_NODELAY, operi interactive destinata. Sed, ignosce, obtine ad valorem default - 200 Milliseconds Si vere vis aliquid depingere simile et nisi in duobus possibilibus fasciculis, differ pro 5 secundis, vel quicquid "Usoris typing..." nuntius timeout nunc est. Sed nulla.

postremo, pings. Hoc est, inhibito nexu TCP vivacitatis. Ridiculum est, sed abhinc circiter X annos textum criticum de nuntio dorm facultatis nostrae scripsi - auctores ibi etiam servo e cliente pingebant, et non vice versa. Sed 10 annus alumni aliud sunt, et officium internationale aliud est, ius?

Primum, parum scholastica. TCP nexus, sine permutatione fasciculi, per septimanas vivere potest. Hoc autem est bonum et malum, secundum propositum. Bonum est si haberes nexum SSH apertum servo, surrexisti e computatro, iter repulsum, ad locum tuum rediit - sessionem per hunc servo scissum non est (non es aliquid typus, nullae erant fasciculi) , Commodum est. Malum est si milia clientium in servo sunt, singuli facultates sumentes (salve, Postgres!), et hospes clientis iam pridem recrebuit - sed nos de ea non scimus.

Chat/IM systemata in alterum casum cadunt pro una causa addito - status online. Si utentis "decidit", suos interlocutores de hac re certiorem facere debes. Alioquin errabis, quod creatores Jabber fecit (et correctum per 20 annos) usorem disiungitur, sed pergunt epistulas ad eum scribere, credens eum esse online (quae etiam in his penitus amisit. paucis minutis ante disconnect repertum). Imo, optio TCP_KEEPALIVE, quam multi qui non intellegunt quomodo TCP timentes laborant passim inicere (proponendo valores silvestres quasi decem secundarum), hic non adiuvabunt - debes efficere ut non solum OS acinum machina usoris vivit, sed etiam fungatur normaliter, respondere posse, et ipsa applicatione (putasne durari non posse? Telegram Desktop in Ubuntu 18.04 mihi plus semel concrevit).

Ut wisi enim ad ping servo client, et non vice versa - si client hoc facit, si nexus fractus est, ping non liberabitur, finis non erit.

Quid in Telegram videmus? Est prorsus contrarium! Bene scilicet. Formaliter, scilicet, ping potest utrimque se. In praxi, clientes fusum utuntur ping_delay_disconnectqui timet servo. Bene, ignosce me, clienti non est decernere quam diu illic sine ping vivere velit. Servus, onere innixus, melius novit. Sed, utique, si facultates non sapis, tum tuum malum Pinoculus eris, et fusum faciet.

Quomodo designatus est?

Supra facta clare indicare credo Telegram/VKontakte turmam in campo onerariis (et inferioris) retis computatoriis non admodum idoneis esse et eorum condicionem humilem in rebus congruentibus.

Cur evenit ut tam multiplex sit et quomodo architecti telegraphum obicere conantur? De facto, quod Sessionem facere conati sunt, nexum TCP superstitem rumpit, i.e., quod nunc non traditum erat, postea trademus. Probabiliter etiam temptaverunt onerariam facere UDP, sed difficultates offenderunt eamque reliquerunt (cur vacua documenta est - nihil iactare). Sed propter defectum intellectus quomodo retia in genere et TCP in opere particulari, ubi in eo innitaris, et ubi debes facere tibi (et quomodo), et conatum hoc coniungendi cum cryptographia "duobus avibus cum unus lapis”, hoc est effectum.

Quomodo necesse fuit? Ex eo quod msg_id necesse est indicationem rei cryptographicae ad prohibendos impetus remonstrandi, erratum est munus ei unico identificanti apponere. Quare, sine fundamentali mutans architecturae hodiernae (cum Updates rivus generatur, id est summus gradus API thema ad aliam partem huius seriei epistularum), necesse est:

Servus tenens TCP nexum cum cliente responsabilitatem accipit - si legerit e neruo, placet agnoscere, processus vel errorem redde, nullum damnum. Tunc confirmatio non est vector iduum, sed simpliciter "sq_no" - tantum numerus, ut in TCP (duo numeri - seq et confirmatus unus). Semper intra sessionem sumus, annon sumus?
Indicatione temporis ad prohibendos impetus remonstrationis fit campus separatus, a la nonce. Retunditur, sed aliud non afficit. satis et uint32 - si sal nostrum mutat saltem per singulos dies dimidium, possumus collocare XVI frusta ad partem ignobilem ordinis integri temporis currentis, reliquam - ad partem fracti secundi (sicut nunc).
remotum msg_id omnino - ex parte distinctionis petitiones in backends, primo, client id, secundo sessionis id, concatenatis. Itaque unum tantum sufficit ut petitur identifier seq_no.

Hoc quoque non est optio felicissima: perfecte temere pro identificatorio fieri potuit - hoc iam factum est in summo gradu API cum nuntium obiter mittit. Utilius est architecturam a relativo ad absolutam omnino reformandam, sed haec est thema alterius partis, non haec posta.

API?

Ta-daam! Ita, cum per iter plenum doloris et fusum elaborati sumus, tandem aliquas petitiones ministranti mittere potuimus, et aliquas responsiones eis recipere, ac renovationes accipere a ministris (non in petitione, sed in ipsa. nos mittit, ut tudites, si quis eo modo clarius est).

Animadverte, nunc unicum exemplum in Perl in artic! (neque enim syntaxis nota est, primum argumentum benedicendi est structura obiecti notitia, secunda genus est);

2019.10.24 12:00:51 $1 = {
'cb' => 'TeleUpd::__ANON__',
'out' => bless( {
'filter' => bless( {}, 'Telegram::ChannelMessagesFilterEmpty' ),
'channel' => bless( {
'access_hash' => '-6698103710539760874',
'channel_id' => '1380524958'
}, 'Telegram::InputPeerChannel' ),
'pts' => '158503',
'flags' => 0,
'limit' => 0
}, 'Telegram::Updates::GetChannelDifference' ),
'req_id' => '6751291954012037292'
};
2019.10.24 12:00:51 $1 = {
'in' => bless( {
'req_msg_id' => '6751291954012037292',
'result' => bless( {
'pts' => 158508,
'flags' => 3,
'final' => 1,
'new_messages' => [],
'users' => [],
'chats' => [
bless( {
'title' => 'Хулиномика',
'username' => 'hoolinomics',
'flags' => 8288,
'id' => 1380524958,
'access_hash' => '-6698103710539760874',
'broadcast' => 1,
'version' => 0,
'photo' => bless( {
'photo_small' => bless( {
'volume_id' => 246933270,
'file_reference' => '
'secret' => '1854156056801727328',
'local_id' => 228648,
'dc_id' => 2
}, 'Telegram::FileLocation' ),
'photo_big' => bless( {
'dc_id' => 2,
'local_id' => 228650,
'file_reference' => '
'secret' => '1275570353387113110',
'volume_id' => 246933270
}, 'Telegram::FileLocation' )
}, 'Telegram::ChatPhoto' ),
'date' => 1531221081
}, 'Telegram::Channel' )
],
'timeout' => 300,
'other_updates' => [
bless( {
'pts_count' => 0,
'message' => bless( {
'post' => 1,
'id' => 852,
'flags' => 50368,
'views' => 8013,
'entities' => [
bless( {
'length' => 20,
'offset' => 0
}, 'Telegram::MessageEntityBold' ),
bless( {
'length' => 18,
'offset' => 480,
'url' => 'https://alexeymarkov.livejournal.com/[url_вырезан].html'
}, 'Telegram::MessageEntityTextUrl' )
],
'reply_markup' => bless( {
'rows' => [
bless( {
'buttons' => [
bless( {
'text' => '???? 165',
'data' => 'send_reaction_0'
}, 'Telegram::KeyboardButtonCallback' ),
bless( {
'data' => 'send_reaction_1',
'text' => '???? 9'
}, 'Telegram::KeyboardButtonCallback' )
]
}, 'Telegram::KeyboardButtonRow' )
]
}, 'Telegram::ReplyInlineMarkup' ),
'message' => 'А вот и новая книга! 
// [текст сообщения вырезан чтоб не нарушать правил Хабра о рекламе]
напечатаю.',
'to_id' => bless( {
'channel_id' => 1380524958
}, 'Telegram::PeerChannel' ),
'date' => 1571724559,
'edit_date' => 1571907562
}, 'Telegram::Message' ),
'pts' => 158508
}, 'Telegram::UpdateEditChannelMessage' ),
bless( {
'pts' => 158508,
'message' => bless( {
'edit_date' => 1571907589,
'to_id' => bless( {
'channel_id' => 1380524958
}, 'Telegram::PeerChannel' ),
'date' => 1571807301,
'message' => 'Почему Вы считаете Facebook плохой компанией? Можете прокомментировать? По-моему, это шикарная компания. Без долгов, с хорошей прибылью, а если решат дивы платить, то и еще могут нехило подорожать.
Для меня ответ совершенно очевиден: потому что Facebook делает ужасный по качеству продукт. Да, у него монопольное положение и да, им пользуется огромное количество людей. Но мир не стоит на месте. Когда-то владельцам Нокии было смешно от первого Айфона. Они думали, что лучше Нокии ничего быть не может и она навсегда останется самым удобным, красивым и твёрдым телефоном - и доля рынка это красноречиво демонстрировала. Теперь им не смешно.
Конечно, рептилоиды сопротивляются напору молодых гениев: так Цукербергом был пожран Whatsapp, потом Instagram. Но всё им не пожрать, Паша Дуров не продаётся!
Так будет и с Фейсбуком. Нельзя всё время делать говно. Кто-то когда-то сделает хороший продукт, куда всё и уйдут.
#соцсети #facebook #акции #рептилоиды',
'reply_markup' => bless( {
'rows' => [
bless( {
'buttons' => [
bless( {
'data' => 'send_reaction_0',
'text' => '???? 452'
}, 'Telegram::KeyboardButtonCallback' ),
bless( {
'text' => '???? 21',
'data' => 'send_reaction_1'
}, 'Telegram::KeyboardButtonCallback' )
]
}, 'Telegram::KeyboardButtonRow' )
]
}, 'Telegram::ReplyInlineMarkup' ),
'entities' => [
bless( {
'length' => 199,
'offset' => 0
}, 'Telegram::MessageEntityBold' ),
bless( {
'length' => 8,
'offset' => 919
}, 'Telegram::MessageEntityHashtag' ),
bless( {
'offset' => 928,
'length' => 9
}, 'Telegram::MessageEntityHashtag' ),
bless( {
'length' => 6,
'offset' => 938
}, 'Telegram::MessageEntityHashtag' ),
bless( {
'length' => 11,
'offset' => 945
}, 'Telegram::MessageEntityHashtag' )
],
'views' => 6964,
'flags' => 50368,
'id' => 854,
'post' => 1
}, 'Telegram::Message' ),
'pts_count' => 0
}, 'Telegram::UpdateEditChannelMessage' ),
bless( {
'message' => bless( {
'reply_markup' => bless( {
'rows' => [
bless( {
'buttons' => [
bless( {
'data' => 'send_reaction_0',
'text' => '???? 213'
}, 'Telegram::KeyboardButtonCallback' ),
bless( {
'data' => 'send_reaction_1',
'text' => '???? 8'
}, 'Telegram::KeyboardButtonCallback' )
]
}, 'Telegram::KeyboardButtonRow' )
]
}, 'Telegram::ReplyInlineMarkup' ),
'views' => 2940,
'entities' => [
bless( {
'length' => 609,
'offset' => 348
}, 'Telegram::MessageEntityItalic' )
],
'flags' => 50368,
'post' => 1,
'id' => 857,
'edit_date' => 1571907636,
'date' => 1571902479,
'to_id' => bless( {
'channel_id' => 1380524958
}, 'Telegram::PeerChannel' ),
'message' => 'Пост про 1С вызвал бурную полемику. Человек 10 (видимо, 1с-программистов) единодушно написали:
// [текст сообщения вырезан чтоб не нарушать правил Хабра о рекламе]
Я бы добавил, что блестящая у 1С дистрибуция, а маркетинг... ну, такое.'
}, 'Telegram::Message' ),
'pts_count' => 0,
'pts' => 158508
}, 'Telegram::UpdateEditChannelMessage' ),
bless( {
'pts' => 158508,
'pts_count' => 0,
'message' => bless( {
'message' => 'Здравствуйте, расскажите, пожалуйста, чем вредит экономике 1С?
// [текст сообщения вырезан чтоб не нарушать правил Хабра о рекламе]
#софт #it #экономика',
'edit_date' => 1571907650,
'date' => 1571893707,
'to_id' => bless( {
'channel_id' => 1380524958
}, 'Telegram::PeerChannel' ),
'flags' => 50368,
'post' => 1,
'id' => 856,
'reply_markup' => bless( {
'rows' => [
bless( {
'buttons' => [
bless( {
'data' => 'send_reaction_0',
'text' => '???? 360'
}, 'Telegram::KeyboardButtonCallback' ),
bless( {
'data' => 'send_reaction_1',
'text' => '???? 32'
}, 'Telegram::KeyboardButtonCallback' )
]
}, 'Telegram::KeyboardButtonRow' )
]
}, 'Telegram::ReplyInlineMarkup' ),
'views' => 4416,
'entities' => [
bless( {
'offset' => 0,
'length' => 64
}, 'Telegram::MessageEntityBold' ),
bless( {
'offset' => 1551,
'length' => 5
}, 'Telegram::MessageEntityHashtag' ),
bless( {
'length' => 3,
'offset' => 1557
}, 'Telegram::MessageEntityHashtag' ),
bless( {
'offset' => 1561,
'length' => 10
}, 'Telegram::MessageEntityHashtag' )
]
}, 'Telegram::Message' )
}, 'Telegram::UpdateEditChannelMessage' )
]
}, 'Telegram::Updates::ChannelDifference' )
}, 'MTProto::RpcResult' )
};
2019.10.24 12:00:51 $1 = {
'in' => bless( {
'update' => bless( {
'user_id' => 2507460,
'status' => bless( {
'was_online' => 1571907651
}, 'Telegram::UserStatusOffline' )
}, 'Telegram::UpdateUserStatus' ),
'date' => 1571907650
}, 'Telegram::UpdateShort' )
};
2019.10.24 12:05:46 $1 = {
'in' => bless( {
'chats' => [],
'date' => 1571907946,
'seq' => 0,
'updates' => [
bless( {
'max_id' => 141719,
'channel_id' => 1295963795
}, 'Telegram::UpdateReadChannelInbox' )
],
'users' => []
}, 'Telegram::Updates' )
};
2019.10.24 13:01:23 $1 = {
'in' => bless( {
'server_salt' => '4914425622822907323',
'unique_id' => '5297282355827493819',
'first_msg_id' => '6751307555044380692'
}, 'MTProto::NewSessionCreated' )
};
2019.10.24 13:24:21 $1 = {
'in' => bless( {
'chats' => [
bless( {
'username' => 'freebsd_ru',
'version' => 0,
'flags' => 5440,
'title' => 'freebsd_ru',
'min' => 1,
'photo' => bless( {
'photo_small' => bless( {
'local_id' => 328733,
'volume_id' => 235140688,
'dc_id' => 2,
'file_reference' => '
'secret' => '4426006807282303416'
}, 'Telegram::FileLocation' ),
'photo_big' => bless( {
'dc_id' => 2,
'file_reference' => '
'volume_id' => 235140688,
'local_id' => 328735,
'secret' => '71251192991540083'
}, 'Telegram::FileLocation' )
}, 'Telegram::ChatPhoto' ),
'date' => 1461248502,
'id' => 1038300508,
'democracy' => 1,
'megagroup' => 1
}, 'Telegram::Channel' )
],
'users' => [
bless( {
'last_name' => 'Panov',
'flags' => 1048646,
'min' => 1,
'id' => 82234609,
'status' => bless( {}, 'Telegram::UserStatusRecently' ),
'first_name' => 'Dima'
}, 'Telegram::User' )
],
'seq' => 0,
'date' => 1571912647,
'updates' => [
bless( {
'pts' => 137596,
'message' => bless( {
'flags' => 256,
'message' => 'Создать джейл с именем покороче ??',
'to_id' => bless( {
'channel_id' => 1038300508
}, 'Telegram::PeerChannel' ),
'id' => 119634,
'date' => 1571912647,
'from_id' => 82234609
}, 'Telegram::Message' ),
'pts_count' => 1
}, 'Telegram::UpdateNewChannelMessage' )
]
}, 'Telegram::Updates' )
};

Imo non praedo de industria - si nondum legeris, perge et fac!

Oh, wai~~... Quid hoc simile? Aliquid familiariter... fortasse haec est notitia structurae typicae Web API in JSON, nisi quod classes etiam obiectis coniunctae sunt?

Ita hoc modo evenit... Quid actum est, socii? sicut incipiens?..Nun JSON super HTTPS simplicius esse voluisset?! Quid habuimus in commutationem? An operae pretium est?

Perpendamus quid TL+MTProto nobis dederit et quid optio possibilis sit. Bene, HTTP, quod exemplar rogatae responsionis intendit, malum idoneum est, sed aliquid saltem super TLS?

Foedus serialization. Hanc notarum structuram viso, JSON similem, memini versiones eius binas esse. Nota MsgPack non minus extensibilis, sed est, exempli gratia, CBOR - obiter, vexillum descriptum. RFC 7049. Notabile est quod definit tags, ut dilatatio mechanismi et in medio iam de mensuris praesto:

25 + 256 - reposuit lineas repetitas cum referente ad numerum lineae, tam vilis compressionis methodus
26 - Obiectum serialized Perl cum genere nominis et argumentis constructor
27 - serialised lingua-independens cum type nomine et argumentis constructor

Bene, easdem in TL et in CBOR datas serialize conatus sum cum chorda et obiecto sarcina para. Eventus in favorem CBOR alicubi ex megabyto variare coepit;

cborlen=1039673 tl_len=1095092

Sic, conclusioni: Formae simpliciores substantialiter sunt quae problemai synchronisationi defectui vel identitatis ignotae non obnoxiae sunt, cum efficacia comparandi.

Fast nexum constitutionis. Hoc significat nulla RTT post renexionem (cum clavis iam semel generata est) - applicabilis est ab ipso primo MTProto nuntius, sed cum aliquibus exceptionibus - eundem salem ferire, sessionem non putridam etc. Quid TLS nobis offert potius? Rei loco:

Cum usura PFS in TLS, TLS sessionis tesserae (RFC 5077) sessionem encryptam resumere sine clavibus re- tractandis et sine clavibus informationis in calculonis servandis. Cum primum nexum aperiens et claves creans, ministrator encryptas nexum civitatis tradit et clienti (forma tessera sessionis) transmittit. Itaque, repetito nexu, client tesseram sessionis, incluso clavem sessionis, remittit servo. Ipsa tessera encrypta est cum clavis temporalis (sessionis clavibus tesserae), quae in calculonis reponitur et distribui debet inter omnes ministros processus SSL in solutionibus aggregatis.[10] Quapropter tessera sessionis introductio PFS violare potest si claves servo temporariae decipiuntur, exempli gratia, cum diu repositae sunt (OpenSSL, nginx, Apache eas per defaltam reponunt per totam durationem progressionis, situs popularis usus. clavis per aliquot horas, usque ad dies).

Hic RTT non nulla est, commutare debes saltem ClientHello et ServerHello, postquam client notitias una cum Fine mittere potest. Sed hic meminisse debemus nos non telam habere cum suo fasciculo nexus nuper apertos, sed nuntium, cuius nexus saepe unus et plus minusve longaevus, interretialis petitiones relative brevia - omnia multiplicantur. internis. Hoc est, satis gratum est si sectionem subway vere malam non offendissemus.

Oblitus aliquid aliud? Scribere in comment.

Tertia pars sequetur?

In secunda parte huius seriei postum considerabimus quaestiones non technicas, sed normas — aditus, ideologia, interfacies, habitus erga utentes, etc. Fundatur tamen de informationibus technicis quae hic allata sunt.

Tertia pars pergit ad experientiam technicam componentis/evolutionis resolvere. Disces in specie;

continuatio pandemonii cum varietate TL specierum
ignota de canalibus et supergroups
Quid alternis peiores roster
de absoluta nobis relativa nuntium addressing
quid intersit inter photo et imaginem
quomodo emoji intermixti litteris cursivis

et alii fusi! Mane suavi!

Source: www.habr.com

Censura protocolli et norma accessionum telegraphi. Pars I, technica: usus scribendi clientem de integro - TL, MT