func (parser *BigRequestsParser) Parse() (res []*HttpBigRequest) {
if (parser.body_writer != nil) && (len(parser.unworked_data) != 0) {
panic(errors.New("(parser.body_writer != nil) && (len(parser.unworked_data) != 0)"))
}
req_identifier := []byte(http_version + endline_str) // Признак запроса (версия HTTP + символы конца строки)
endl := []byte(endline_str)
for len(parser.unworked_data) > 0 {
if parser.unfinished_req == nil {
// Обрабатываем накопленные данные как начало нового запроса
p_req_id := bytes.Index(parser.unworked_data, req_identifier)
p_endl := -1
if p_req_id >= 0 {
p_endl = bytes.LastIndex(parser.unworked_data[:p_req_id], endl)
} else {
p_endl = bytes.LastIndex(parser.unworked_data, endl)
}
if p_req_id < 0 {
// Признак запроса не был обнаружен
if p_endl > 0 {
// ...но был обнаружен переход на новую строку - ошибка
parser.unworked_data = parser.unworked_data[p_endl+len(endline_str):]
if len(parser.unworked_data) == 0 {
parser.unworked_data = nil
}
res = append(res, nil)
}
return
} else {
p_req_id += len(req_identifier)
}
if p_endl < 0 {
p_endl = 0
} else {
// Обнаружен переход на новую строку перед признаком запроса
res = append(res, nil)
p_endl += len(endline_str)
}
// Найден признак запроса
req_head_line := string(parser.unworked_data[p_endl:p_req_id])
parser.unworked_data = parser.unworked_data[p_req_id:]
if len(parser.unworked_data) == 0 {
parser.unworked_data = nil
}
params := strings.Split(req_head_line, " ")
if len(params) == 3 {
// Нашли заголовок запроса
parser.unfinished_req = &HttpBigRequest{Type: params[0], Host: params[1]}
} else {
// Неверный заголовок
res = append(res, nil)
continue
}
} // if parser.unfinished_req == nil
// Формируем параметры заголовка
param_error := false
pos := bytes.Index(parser.unworked_data, endl)
for ; pos >= 0; pos = bytes.Index(parser.unworked_data, endl) {
// Формируем строку с параметром (без символа перехода на следующую строку)
// и отрезаем обработанный кусок данных от необработанных данных (вместе с символом перехода)
one_param_str := string(parser.unworked_data[:pos])
parser.unworked_data = parser.unworked_data[pos+len(endl):]
if len(parser.unworked_data) == 0 {
parser.unworked_data = nil
}
if pos == 0 {
// Дошли до конца заголовка
break
}
// Обрабатываем параметр заголовка
param, success := param_parser(one_param_str)
if success {
// Обработали один параметр - добавляем его е запросу
parser.unfinished_req.HeaderParams = append(parser.unfinished_req.HeaderParams, param)
} else {
// Ошибка разбора параметра заголовка
parser.unfinished_req = nil
res = append(res, nil)
param_error = true
break
}
} // for ; pos >= 0; pos = bytes.Index(parser.unworked_data, endl)
if param_error {
// При разборке параметров заголовка произошла ошибка
continue
} else if pos < 0 {
// Символ перехода на следующую строку не найден - больше обрабатывать нечего
return
}
// Если попали сюда - параметры заголовка считаны полностью,
// дальше идёт тело и/или следующий запрос
var body_len int = len(parser.unworked_data)
for _, param := range parser.unfinished_req.HeaderParams {
if param.Name == BodySizeParamName {
// Обнаружили параметр длины тела
var e error
body_len, e = strconv.Atoi(param.Value)
if e != nil {
// Некорректное значение параметра длины
parser.unfinished_req = nil
res = append(res, nil)
param_error = true
}
break
} // if param.Name == BodySizeParamName
} // for _, param := range parser.unfinished_req.HeaderParams
if param_error {
continue
}
if body_len <= len(parser.unworked_data) {
// В необработанных данных уже содержится всё тело запроса
parser.unfinished_req.Body = bytes.NewReader(parser.unworked_data[:body_len])
parser.unworked_data = parser.unworked_data[body_len:]
if len(parser.unworked_data) == 0 {
parser.unworked_data = nil
}
} else if body_len != 0 {
// Всё тело ещё не считали
var one_piece_max_sz int = body_len
var chan_sz uint16 = 2
if one_piece_max_sz > 10240 {
one_piece_max_sz = 10240
chan_sz = 10
}
reader, writer := IoUtils.NonBlockingPipe(one_piece_max_sz, chan_sz)
parser.body_writer = IoUtils.LimitWriteCloser(writer, int64(body_len))
parser.unfinished_req.Body = io.LimitReader(reader, int64(body_len))
if parser.unworked_data != nil {
sz, e := parser.body_writer.Write(parser.unworked_data)
if (sz < len(parser.unworked_data)) || (e != nil) {
// Были записаны не все данные
panic(errors.New("Ошибка записи тела запроса")) // Возможно, стоит убрать
}
parser.unworked_data = nil
}
}
res = append(res, parser.unfinished_req)
parser.unfinished_req = nil
} // for len(parser.unworked_data) > 0
return res
} // func (p *BigRequestsParser) Parse() []*HttpBigRequest
// Разбор полученных данных
func (p *BigFrameParser) Parse() (res []BigFrame) {
for len(p.unworked_data) > 0 {
if p.data_writer != nil {
panic(errors.New("Не закончили запись данных предыдущего пакета, а уже есть данные для нового"))
}
// Начинаем формировать новый пакет
head_len := 2 // Длина заголовка (минимум 2 байта)
data_len := len(p.unworked_data)
if data_len < head_len {
// Недостаточно данных даже для формирования заголовка
return
}
if (0x80 & p.unworked_data[1]) != 0 {
// В заголовке присутствует маска - +4 байта к заголовку
head_len += 4
}
if ln_param := 0x7F & p.unworked_data[1]; ln_param == 126 {
// Поле длины пакета занимает лишние 2 байта
head_len += 2
} else if ln_param == 127 {
// Поле длины пакета занимает лишние 8 байт
head_len += 8
}
if data_len < head_len {
// Недостаточно данных даже для формироваиня заголовка
return
}
// Формируем заголовок пакета
new_frame := BigFrame{}
new_frame.Fin = (0x80 & p.unworked_data[0]) != 0
for t := byte(0); t < 3; t++ {
new_frame.Rsvs[t] = (p.unworked_data[0] & (byte(0x40) >> t)) != 0
}
new_frame.Type = 0xF & p.unworked_data[0]
new_frame.Mask = (0x80 & p.unworked_data[1]) != 0
if new_frame.Mask {
for i := 0; i < 4; i++ {
new_frame.MaskKey[i] = p.unworked_data[head_len-4+i]
}
}
data_sz := uint64(0x7F & p.unworked_data[1])
if data_sz == 126 {
data_sz = 0
for _, v := range p.unworked_data[2:4] {
data_sz <<= 8
data_sz |= uint64(v)
}
} else if data_sz > 126 {
data_sz = 0
for _, v := range p.unworked_data[2:10] {
data_sz <<= 8
data_sz |= uint64(v)
}
}
p.unworked_data = p.unworked_data[head_len:]
if len(p.unworked_data) == 0 {
p.unworked_data = nil
}
// Формируем данные пакета
if data_sz <= uint64(len(p.unworked_data)) {
// Считано достаточно данных для форрмирования тела
frame_data := p.unworked_data[:data_sz]
p.unworked_data = p.unworked_data[data_sz:]
if len(p.unworked_data) == 0 {
p.unworked_data = nil
}
if new_frame.Mask {
// Задана маска - расшифровываем данные
for i := range frame_data {
frame_data[i] = frame_data[i] ^ new_frame.MaskKey[i%4]
}
}
new_frame.Data = bytes.NewReader(frame_data)
} else {
// Всё тело ещё не считали
var one_piece_max_sz int = int(data_sz)
var chan_sz uint16 = 2
if one_piece_max_sz > 10240 {
one_piece_max_sz = 10240
chan_sz = 10
}
reader, writer := IoUtils.NonBlockingPipe(one_piece_max_sz, chan_sz)
p.data_writer = IoUtils.LimitWriteCloser(writer, int64(data_sz))
var conv IoUtils.Converter
if new_frame.Mask {
conv = &frame_data_converter{mask_key: new_frame.MaskKey}
}
new_frame.Data = IoUtils.Serialize(nil, io.LimitReader(reader, int64(data_sz)), conv, nil)
if p.unworked_data != nil {
sz, e := p.data_writer.Write(p.unworked_data)
if (sz < len(p.unworked_data)) || (e != nil) {
// Были записаны не все данные
panic(errors.New("Ошибка записи тела запроса")) // Возможно, стоит убрать
}
p.unworked_data = nil
}
}
// Пакет сформирован
res = append(res, new_frame)
} // for len(r.unworked_data) > 0
return
} // func (p *BigFrameParser) Parse() (res []BigFrame)